From c3c528083b6180cc1fcde2c4b97cda1cb3285c74 Mon Sep 17 00:00:00 2001 From: Sander Bosma Date: Tue, 11 Mar 2025 10:27:22 +0100 Subject: [PATCH 01/24] fix: relayer fork handling --- relayer/Cargo.toml | 1 + relayer/src/main.rs | 2 + relayer/src/relayer.rs | 209 ++++++++++++++++++++++++++++++++++------- 3 files changed, 179 insertions(+), 33 deletions(-) diff --git a/relayer/Cargo.toml b/relayer/Cargo.toml index 8132f533d..c64a10ee3 100644 --- a/relayer/Cargo.toml +++ b/relayer/Cargo.toml @@ -18,3 +18,4 @@ bitcoincore-rpc.workspace = true # Ethereum alloy = { workspace = true, features = ["full", "providers", "node-bindings"] } +serde_json = "1.0.140" diff --git a/relayer/src/main.rs b/relayer/src/main.rs index 7d8195064..a2ffabbe3 100644 --- a/relayer/src/main.rs +++ b/relayer/src/main.rs @@ -37,6 +37,8 @@ async fn main() -> Result<()> { // env_logger::init(); let app = App::parse(); + println!("Starting relayer..."); + let privk = app.private_key.trim().strip_prefix("0x").expect("Requires private key"); let signer: PrivateKeySigner = privk.parse().expect("should parse private key"); let wallet = EthereumWallet::from(signer); diff --git a/relayer/src/relayer.rs b/relayer/src/relayer.rs index c1239b50b..64efb3375 100644 --- a/relayer/src/relayer.rs +++ b/relayer/src/relayer.rs @@ -1,10 +1,15 @@ use alloy::{ network::ReceiptResponse, primitives::{Bytes, FixedBytes, U256}, + rpc::types::Transaction, + sol_types::SolCall, + transports::RpcError, }; use bindings::fullrelaywithverify::FullRelayWithVerify::FullRelayWithVerifyInstance as BitcoinRelayInstance; use bitcoin::{block::Header as BitcoinHeader, consensus, hashes::Hash, BlockHash}; use eyre::{eyre, Result}; +use reqwest::Client; +use serde_json::Value; use std::time::Duration; use utils::EsploraClient; @@ -44,46 +49,62 @@ pub struct Relayer< impl< T: alloy::contract::private::Transport + ::core::clone::Clone, P: alloy::contract::private::Provider, - N: alloy::contract::private::Network, + N: alloy::contract::private::Network, > Relayer { pub fn new(contract: BitcoinRelayInstance, esplora_client: EsploraClient) -> Self { Self { contract, esplora_client } } - async fn find_latest_height(&self) -> Result { - let latest_digest = self.contract.getBestKnownDigest().call().await?._0; - let mut latest_height: u32 = - self.contract.findHeight(latest_digest).call().await?._0.try_into().unwrap(); + async fn relayed_height(&self) -> Result { + let relayer_blockhash = self.contract.getBestKnownDigest().call().await?._0; + let relayed_height: u32 = + self.contract.findHeight(relayer_blockhash).call().await?._0.try_into().unwrap(); - let mut latest = self - .esplora_client - .get_block_header(&BlockHash::from_byte_array(latest_digest.0)) - .await?; + Ok(relayed_height) + } - let mut better_or_same = - self.esplora_client.get_block_header_at_height(latest_height).await?; + async fn has_relayed(&self, blockhash: BlockHash) -> Result { + let result = self.contract.findHeight(blockhash.to_byte_array().into()).call().await; - while latest != better_or_same { - println!("wrong header"); - latest = self.esplora_client.get_block_header(&latest.prev_blockhash).await?; - latest_height -= 1; - better_or_same = self.esplora_client.get_block_header_at_height(latest_height).await?; + match result { + Ok(_) => Ok(true), + Err(alloy::contract::Error::TransportError(RpcError::ErrorResp(_e))) => { + // If the block is not relayed, the findHeight call reverts. + return Ok(false); + } + Err(e) => Err(e)?, // something else went wrong (e.g. network issues) } + } + + async fn latest_common_height(&self) -> Result { + // Start at the tip of the relayed chain, then move back until we find a block that matches bitcoin chain. + // We do it like this because calling esplora.get_block_hash for a block in a fork will fail. + let mut height = self.relayed_height().await?; - Ok(latest_height) + loop { + let actual_hash = self.esplora_client.get_block_hash(height).await?; + let is_relayed = self.has_relayed(actual_hash).await?; + + if is_relayed { + return Ok(height); + } + + println!("Found fork: {actual_hash} at height {height}"); + height -= 1; + } } #[allow(unused)] pub async fn run_once(&self) -> Result<()> { - let latest_height = self.find_latest_height().await?; + let latest_height = self.latest_common_height().await?; let headers: Vec = self.pull_headers(latest_height).await?; self.push_headers(headers).await?; Ok(()) } pub async fn run(&self) -> Result<()> { - let mut latest_height = self.find_latest_height().await?; + let mut latest_height = self.latest_common_height().await?; loop { let headers = self.pull_headers(latest_height).await?; @@ -231,20 +252,7 @@ impl< } async fn update_best_digest(&self, new_best: RelayHeader) -> Result<()> { - let current_best_digest_raw = self.contract.getBestKnownDigest().call().await?._0; - let current_best_digest = BlockHash::from_byte_array(current_best_digest_raw.0); - let current_best = RelayHeader { - hash: current_best_digest, - header: self.esplora_client.get_block_header(¤t_best_digest).await?, - height: self - .contract - .findHeight(current_best_digest_raw) - .call() - .await? - ._0 - .try_into() - .unwrap(), - }; + let current_best = self.get_heaviest_relayed_block_header().await?; let ancestor = self.find_lca(&new_best, current_best.clone()).await?; let delta = new_best.height - ancestor.height + 1; @@ -265,4 +273,139 @@ impl< Ok(()) } + + /// Fetch the block header from the contract. We used to fetch from esplora but that would + /// fail if there was a fork. This function is currently a bit over engineered - it uses + /// a subgraph to find the tx that submitted the heaviest block, then takes the blockheader + /// from its calldata. It would have been a lot easier if the smart contract were to store + /// the blockheader directly - something we might do in the future. That would come at the + /// cost of additional gas usage though. + async fn get_heaviest_relayed_block_header(&self) -> Result { + let relayer_blockhash = self.contract.getBestKnownDigest().call().await?._0; + + let query = format!( + r#" + query MyQuery {{ + newTips( + first: 1 + orderBy: block_number + orderDirection: desc + where: {{to: "{relayer_blockhash}"}} + ) {{ + transactionHash_ + }} + }} + "# + ); + + let res: Value = Client::new() + .post("https://api.goldsky.com/api/public/project_clto8zgmd1jbw01xig1ge1u0h/subgraphs/Relay-sepolia/1.0.0/gn") + .json(&serde_json::json!({ "query": query })) + .send() + .await? + .json() + .await?; + + let txid = res["data"]["newTips"] + .as_array() + .and_then(|x| x.first()) + .and_then(|x| x.as_object()) + .and_then(|x| x.get("transactionHash_")) + .and_then(|x| x.as_str()) + .ok_or(eyre!("No events in the subgraph"))? + .to_string(); + + let txid: [u8; 32] = alloy::hex::decode(txid)?.try_into().unwrap(); + + let tx = self.contract.provider().get_transaction_by_hash(txid.into()).await?.unwrap(); + use alloy::consensus::Transaction; + + let input = tx.as_ref().input(); + + use bindings::fullrelaywithverify::FullRelayWithVerify::markNewHeaviestCall; + + let decoded = markNewHeaviestCall::abi_decode(&input, true)?; + let header: bitcoin::block::Header = bitcoin::consensus::deserialize(&decoded._newBest.0)?; + + let height = self.contract.findHeight(relayer_blockhash).call().await?._0; + let hash = bitcoin::BlockHash::from_slice(&relayer_blockhash.0)?; + Ok(RelayHeader { hash, header, height: height.try_into()? }) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use alloy::hex; + use alloy::{ + network::EthereumWallet, + primitives::TxHash, + providers::{Provider, ProviderBuilder}, + signers::local::PrivateKeySigner, + sol_types::SolCall, + }; + use reqwest::Url; + + #[tokio::test] + async fn test_has_relayed() -> Result<()> { + let relayer = Relayer::new( + BitcoinRelayInstance::new( + "0xaAD39528eB8b3c70b613C442F351610969974fDF".parse()?, + ProviderBuilder::new().on_http("https://bob-sepolia.rpc.gobob.xyz/".parse()?), + ), + EsploraClient::new( + Some("https://btc-signet.gobob.xyz/".to_string()), + bitcoin::Network::Bitcoin, + )?, + ); + + assert!(!relayer.has_relayed(BlockHash::from_slice(&[1u8; 32])?).await?); + assert!( + relayer + .has_relayed(BlockHash::from_slice(&hex::decode( + "0x915c9fffe077970ee032ed8be0c6953fe2a4ab9827ca151e4977a6d72a010000" + )?)?) + .await? + ); + + Ok(()) + } + + #[tokio::test] + #[ignore] // Run this manually with anvil --fork-url wss://bob-sepolia.rpc.gobob.xyz --fork-block-number 9563094 + async fn test_latest_common_height() -> Result<()> { + let relayer = Relayer::new( + BitcoinRelayInstance::new( + "0xaAD39528eB8b3c70b613C442F351610969974fDF".parse()?, + ProviderBuilder::new().on_http("http://127.0.0.1:8545".parse()?), + ), + EsploraClient::new( + Some("https://btc-signet.gobob.xyz/".to_string()), + bitcoin::Network::Bitcoin, + )?, + ); + + assert_eq!(relayer.relayed_height().await?, 238513); + assert_eq!(relayer.latest_common_height().await?, 238512); + Ok(()) + } + + #[tokio::test] + async fn test_heaviest_relayed_block_header() -> Result<()> { + let relayer = Relayer::new( + BitcoinRelayInstance::new( + "0xaAD39528eB8b3c70b613C442F351610969974fDF".parse()?, + ProviderBuilder::new().on_http("https://bob-sepolia.rpc.gobob.xyz/".parse()?), + ), + EsploraClient::new( + Some("https://btc-signet.gobob.xyz/".to_string()), + bitcoin::Network::Bitcoin, + )?, + ); + + // Not much we can easily test except that we find an actual block header + relayer.get_heaviest_relayed_block_header().await?; + + Ok(()) + } } From 6dc4d99be927c4741d9b78c8f49cb38bc3077397 Mon Sep 17 00:00:00 2001 From: Gregory Hill Date: Mon, 9 Jun 2025 15:30:21 +0100 Subject: [PATCH 02/24] chore: align submodules Signed-off-by: Gregory Hill --- contracts/lib/forge-std | 2 +- relayer/src/relayer.rs | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/contracts/lib/forge-std b/contracts/lib/forge-std index f73c73d20..77041d2ce 160000 --- a/contracts/lib/forge-std +++ b/contracts/lib/forge-std @@ -1 +1 @@ -Subproject commit f73c73d2018eb6a111f35e4dae7b4f27401e9421 +Subproject commit 77041d2ce690e692d6e03cc812b57d1ddaa4d505 diff --git a/relayer/src/relayer.rs b/relayer/src/relayer.rs index 3cf35c0bf..da3a2e03c 100644 --- a/relayer/src/relayer.rs +++ b/relayer/src/relayer.rs @@ -86,6 +86,9 @@ impl< } println!("Found fork: {actual_hash} at height {height}"); + if height == 0 { + return Err(eyre!("No common height found before reaching 0")); + } height -= 1; } } From 4d6a616238009320a73368d85262c6cdd7e61aa4 Mon Sep 17 00:00:00 2001 From: Gregory Hill Date: Mon, 9 Jun 2025 15:37:40 +0100 Subject: [PATCH 03/24] chore: fmt Signed-off-by: Gregory Hill --- relayer/src/relayer.rs | 31 ++++++++++++------------------- 1 file changed, 12 insertions(+), 19 deletions(-) diff --git a/relayer/src/relayer.rs b/relayer/src/relayer.rs index da3a2e03c..033692ca3 100644 --- a/relayer/src/relayer.rs +++ b/relayer/src/relayer.rs @@ -73,8 +73,9 @@ impl< } async fn latest_common_height(&self) -> Result { - // Start at the tip of the relayed chain, then move back until we find a block that matches bitcoin chain. - // We do it like this because calling esplora.get_block_hash for a block in a fork will fail. + // Start at the tip of the relayed chain, then move back until we find a block that matches + // bitcoin chain. We do it like this because calling esplora.get_block_hash for a + // block in a fork will fail. let mut height = self.relayed_height().await?; loop { @@ -334,8 +335,8 @@ impl< #[cfg(test)] mod tests { use super::*; - use alloy::hex; use alloy::{ + hex, network::EthereumWallet, primitives::TxHash, providers::{Provider, ProviderBuilder}, @@ -349,12 +350,9 @@ mod tests { let relayer = Relayer::new( BitcoinRelayInstance::new( "0xaAD39528eB8b3c70b613C442F351610969974fDF".parse()?, - ProviderBuilder::new().on_http("https://bob-sepolia.rpc.gobob.xyz/".parse()?), + ProviderBuilder::new().connect_http("https://bob-sepolia.rpc.gobob.xyz/".parse()?), ), - EsploraClient::new( - Some("https://btc-signet.gobob.xyz/".to_string()), - bitcoin::Network::Bitcoin, - )?, + EsploraClient::new(bitcoin::Network::Signet)?, ); assert!(!relayer.has_relayed(BlockHash::from_slice(&[1u8; 32])?).await?); @@ -370,17 +368,15 @@ mod tests { } #[tokio::test] - #[ignore] // Run this manually with anvil --fork-url wss://bob-sepolia.rpc.gobob.xyz --fork-block-number 9563094 + #[ignore] // Run this manually with anvil --fork-url wss://bob-sepolia.rpc.gobob.xyz --fork-block-number + // 9563094 async fn test_latest_common_height() -> Result<()> { let relayer = Relayer::new( BitcoinRelayInstance::new( "0xaAD39528eB8b3c70b613C442F351610969974fDF".parse()?, - ProviderBuilder::new().on_http("http://127.0.0.1:8545".parse()?), + ProviderBuilder::new().connect_http("http://127.0.0.1:8545".parse()?), ), - EsploraClient::new( - Some("https://btc-signet.gobob.xyz/".to_string()), - bitcoin::Network::Bitcoin, - )?, + EsploraClient::new(bitcoin::Network::Signet)?, ); assert_eq!(relayer.relayed_height().await?, 238513); @@ -393,12 +389,9 @@ mod tests { let relayer = Relayer::new( BitcoinRelayInstance::new( "0xaAD39528eB8b3c70b613C442F351610969974fDF".parse()?, - ProviderBuilder::new().on_http("https://bob-sepolia.rpc.gobob.xyz/".parse()?), + ProviderBuilder::new().connect_http("https://bob-sepolia.rpc.gobob.xyz/".parse()?), ), - EsploraClient::new( - Some("https://btc-signet.gobob.xyz/".to_string()), - bitcoin::Network::Bitcoin, - )?, + EsploraClient::new(bitcoin::Network::Bitcoin)?, ); // Not much we can easily test except that we find an actual block header From b983940f2d37abbd43fa4085948e046cf0d27db1 Mon Sep 17 00:00:00 2001 From: Gregory Hill Date: Tue, 10 Jun 2025 10:34:51 +0100 Subject: [PATCH 04/24] chore: clippy Signed-off-by: Gregory Hill --- relayer/src/relayer.rs | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-) diff --git a/relayer/src/relayer.rs b/relayer/src/relayer.rs index 033692ca3..4c6764264 100644 --- a/relayer/src/relayer.rs +++ b/relayer/src/relayer.rs @@ -66,7 +66,7 @@ impl< Ok(_) => Ok(true), Err(alloy::contract::Error::TransportError(RpcError::ErrorResp(_e))) => { // If the block is not relayed, the findHeight call reverts. - return Ok(false); + Ok(false) } Err(e) => Err(e)?, // something else went wrong (e.g. network issues) } @@ -323,7 +323,7 @@ impl< use bindings::fullrelaywithverify::FullRelayWithVerify::markNewHeaviestCall; - let decoded = markNewHeaviestCall::abi_decode(&input)?; + let decoded = markNewHeaviestCall::abi_decode(input)?; let header: bitcoin::block::Header = bitcoin::consensus::deserialize(&decoded._newBest.0)?; let height = self.contract.findHeight(relayer_blockhash).call().await?; @@ -335,15 +335,7 @@ impl< #[cfg(test)] mod tests { use super::*; - use alloy::{ - hex, - network::EthereumWallet, - primitives::TxHash, - providers::{Provider, ProviderBuilder}, - signers::local::PrivateKeySigner, - sol_types::SolCall, - }; - use reqwest::Url; + use alloy::{hex, providers::ProviderBuilder}; #[tokio::test] async fn test_has_relayed() -> Result<()> { From 0339d1dcdd4ad3a556e37a2e3ab9daf49f5b6e8a Mon Sep 17 00:00:00 2001 From: nazeh Date: Tue, 10 Jun 2025 13:42:54 +0300 Subject: [PATCH 05/24] feat(relayer): add lib.rs --- relayer/src/lib.rs | 3 +++ relayer/src/main.rs | 3 +-- 2 files changed, 4 insertions(+), 2 deletions(-) create mode 100644 relayer/src/lib.rs diff --git a/relayer/src/lib.rs b/relayer/src/lib.rs new file mode 100644 index 000000000..f899b8871 --- /dev/null +++ b/relayer/src/lib.rs @@ -0,0 +1,3 @@ +mod relayer; + +pub use relayer::Relayer; diff --git a/relayer/src/main.rs b/relayer/src/main.rs index f3f3694a2..9ba265a0b 100644 --- a/relayer/src/main.rs +++ b/relayer/src/main.rs @@ -5,11 +5,10 @@ use alloy::{ use bindings::fullrelaywithverify::FullRelayWithVerify as BitcoinRelay; use clap::Parser; use eyre::Result; -use relayer::Relayer; use reqwest::Url; use utils::EsploraClient; -mod relayer; +use bob_relayer::Relayer; /// Relayer #[derive(Debug, Parser)] From f9dcdc3579c1a9644d7425813021c02acfb556b2 Mon Sep 17 00:00:00 2001 From: nazeh Date: Wed, 11 Jun 2025 10:58:32 +0300 Subject: [PATCH 06/24] feat(relayer): make Relayer::new() less dependent on generics --- relayer/src/main.rs | 17 ++++----- relayer/src/relayer.rs | 84 +++++++++++++++++++++++++++--------------- 2 files changed, 63 insertions(+), 38 deletions(-) diff --git a/relayer/src/main.rs b/relayer/src/main.rs index 9ba265a0b..539e3604d 100644 --- a/relayer/src/main.rs +++ b/relayer/src/main.rs @@ -1,8 +1,4 @@ -use alloy::{ - network::EthereumWallet, primitives::Address, providers::ProviderBuilder, - signers::local::PrivateKeySigner, -}; -use bindings::fullrelaywithverify::FullRelayWithVerify as BitcoinRelay; +use alloy::{network::EthereumWallet, primitives::Address, signers::local::PrivateKeySigner}; use clap::Parser; use eyre::Result; use reqwest::Url; @@ -42,13 +38,12 @@ async fn main() -> Result<()> { let signer: PrivateKeySigner = privk.parse().expect("should parse private key"); let wallet = EthereumWallet::from(signer); let rpc_url: Url = app.eth_rpc_url.parse()?; - let provider = ProviderBuilder::new().wallet(wallet).connect_http(rpc_url); let esplora_client = app .esplora_url .map(EsploraClient::new_with_url) .unwrap_or(EsploraClient::new(bitcoin::Network::Bitcoin))?; - let relayer = Relayer::new(BitcoinRelay::new(app.relay_address, provider), esplora_client); + let relayer = Relayer::new(rpc_url, app.relay_address, esplora_client, wallet); relayer.run().await?; Ok(()) @@ -64,6 +59,7 @@ mod tests { providers::ProviderBuilder, signers::local::PrivateKeySigner, }; + use bindings::fullrelaywithverify::FullRelayWithVerify as BitcoinRelay; use bitcoin::hashes::Hash; #[tokio::test] @@ -73,7 +69,7 @@ mod tests { let wallet = EthereumWallet::from(signer.clone()); let rpc_url = anvil.endpoint_url(); - let provider = ProviderBuilder::new().wallet(wallet).connect_http(rpc_url); + let provider = ProviderBuilder::new().wallet(wallet.clone()).connect_http(rpc_url.clone()); let esplora_client = EsploraClient::new(bitcoin::Network::Bitcoin)?; @@ -107,7 +103,10 @@ mod tests { // assert!(receipt.status()); - Relayer::new(contract, esplora_client).run_once().await?; + let relayer = Relayer::new(rpc_url, *contract.address(), esplora_client, wallet); + // TODO: test again after using the contract instead of goldsky for regtest at + // `Relayer:get_heaviest_relayed_block_header()` + // relayer.run_once().await?; Ok(()) } diff --git a/relayer/src/relayer.rs b/relayer/src/relayer.rs index 4c6764264..653785724 100644 --- a/relayer/src/relayer.rs +++ b/relayer/src/relayer.rs @@ -1,20 +1,41 @@ use alloy::{ - network::ReceiptResponse, - primitives::{Bytes, FixedBytes, U256}, - rpc::types::Transaction, + network::EthereumWallet, + primitives::{Address, Bytes, FixedBytes, U256}, + providers::{ + fillers::{ + BlobGasFiller, ChainIdFiller, FillProvider, GasFiller, JoinFill, NonceFiller, + WalletFiller, + }, + Identity, Provider, ProviderBuilder, RootProvider, + }, + signers::local::PrivateKeySigner, sol_types::SolCall, transports::RpcError, }; -use bindings::fullrelaywithverify::FullRelayWithVerify::FullRelayWithVerifyInstance as BitcoinRelayInstance; +use bindings::fullrelaywithverify::{ + FullRelayWithVerify as BitcoinRelay, + FullRelayWithVerify::FullRelayWithVerifyInstance as BitcoinRelayInstance, +}; use bitcoin::{block::Header as BitcoinHeader, consensus, hashes::Hash, BlockHash}; use eyre::{eyre, Result}; -use reqwest::Client; +use reqwest::{Client, Url}; use serde_json::Value; use std::time::Duration; use utils::EsploraClient; const HEADERS_PER_BATCH: usize = 5; +type ContractProvider = FillProvider< + JoinFill< + JoinFill< + Identity, + JoinFill>>, + >, + WalletFiller, + >, + RootProvider, +>; + fn serialize_headers(headers: &[RelayHeader]) -> Result> { Ok(headers.iter().flat_map(|header| consensus::serialize(&header.header)).collect()) } @@ -36,21 +57,32 @@ impl RelayHeader { } } -pub struct Relayer, N: alloy::providers::Network> { - pub contract: BitcoinRelayInstance, +pub struct Relayer { + pub contract: BitcoinRelayInstance, pub esplora_client: EsploraClient, } // https://github.com/summa-tx/relays/tree/master/maintainer/maintainer/header_forwarder -impl< - P: alloy::providers::Provider, - N: alloy::providers::Network, - > Relayer -{ - pub fn new(contract: BitcoinRelayInstance, esplora_client: EsploraClient) -> Self { +impl Relayer { + pub fn new( + bob_url: Url, + relay_address: Address, + esplora_client: EsploraClient, + wallet: EthereumWallet, + ) -> Self { + let provider = ProviderBuilder::new().wallet(wallet).connect_http(bob_url); + let contract = BitcoinRelay::new(relay_address, provider); + Self { contract, esplora_client } } + pub fn read_only(bob_url: Url, relay_address: Address, esplora_client: EsploraClient) -> Self { + let signer = PrivateKeySigner::random(); + let wallet = EthereumWallet::from(signer); + + Self::new(bob_url, relay_address, esplora_client, wallet) + } + async fn relayed_height(&self) -> Result { let relayer_blockhash = self.contract.getBestKnownDigest().call().await?; let relayed_height: u32 = @@ -335,15 +367,13 @@ impl< #[cfg(test)] mod tests { use super::*; - use alloy::{hex, providers::ProviderBuilder}; + use alloy::hex; #[tokio::test] async fn test_has_relayed() -> Result<()> { - let relayer = Relayer::new( - BitcoinRelayInstance::new( - "0xaAD39528eB8b3c70b613C442F351610969974fDF".parse()?, - ProviderBuilder::new().connect_http("https://bob-sepolia.rpc.gobob.xyz/".parse()?), - ), + let relayer = Relayer::read_only( + "https://bob-sepolia.rpc.gobob.xyz/".parse()?, + "0xaAD39528eB8b3c70b613C442F351610969974fDF".parse()?, EsploraClient::new(bitcoin::Network::Signet)?, ); @@ -363,11 +393,9 @@ mod tests { #[ignore] // Run this manually with anvil --fork-url wss://bob-sepolia.rpc.gobob.xyz --fork-block-number // 9563094 async fn test_latest_common_height() -> Result<()> { - let relayer = Relayer::new( - BitcoinRelayInstance::new( - "0xaAD39528eB8b3c70b613C442F351610969974fDF".parse()?, - ProviderBuilder::new().connect_http("http://127.0.0.1:8545".parse()?), - ), + let relayer = Relayer::read_only( + "http://127.0.0.1:8545".parse()?, + "0xaAD39528eB8b3c70b613C442F351610969974fDF".parse()?, EsploraClient::new(bitcoin::Network::Signet)?, ); @@ -378,11 +406,9 @@ mod tests { #[tokio::test] async fn test_heaviest_relayed_block_header() -> Result<()> { - let relayer = Relayer::new( - BitcoinRelayInstance::new( - "0xaAD39528eB8b3c70b613C442F351610969974fDF".parse()?, - ProviderBuilder::new().connect_http("https://bob-sepolia.rpc.gobob.xyz/".parse()?), - ), + let relayer = Relayer::read_only( + "https://bob-sepolia.rpc.gobob.xyz/".parse()?, + "0xaAD39528eB8b3c70b613C442F351610969974fDF".parse()?, EsploraClient::new(bitcoin::Network::Bitcoin)?, ); From 92064eb5b5cc4a5965e3c0622466fe0f5341a8eb Mon Sep 17 00:00:00 2001 From: nazeh Date: Wed, 11 Jun 2025 12:45:38 +0300 Subject: [PATCH 07/24] feat(relayer): add get_heaviest_relayed_block_header_regtest --- relayer/src/main.rs | 5 +---- relayer/src/relayer.rs | 22 +++++++++++++++++++++- 2 files changed, 22 insertions(+), 5 deletions(-) diff --git a/relayer/src/main.rs b/relayer/src/main.rs index 539e3604d..64f681ca7 100644 --- a/relayer/src/main.rs +++ b/relayer/src/main.rs @@ -103,10 +103,7 @@ mod tests { // assert!(receipt.status()); - let relayer = Relayer::new(rpc_url, *contract.address(), esplora_client, wallet); - // TODO: test again after using the contract instead of goldsky for regtest at - // `Relayer:get_heaviest_relayed_block_header()` - // relayer.run_once().await?; + Relayer::new(rpc_url, *contract.address(), esplora_client, wallet).run_once().await?; Ok(()) } diff --git a/relayer/src/relayer.rs b/relayer/src/relayer.rs index 653785724..fd9830218 100644 --- a/relayer/src/relayer.rs +++ b/relayer/src/relayer.rs @@ -283,7 +283,11 @@ impl Relayer { } async fn update_best_digest(&self, new_best: RelayHeader) -> Result<()> { - let current_best = self.get_heaviest_relayed_block_header().await?; + let current_best = if self.contract.provider().client().is_local() { + self.get_heaviest_relayed_block_header_regtest().await? + } else { + self.get_heaviest_relayed_block_header().await? + }; let ancestor = self.find_lca(&new_best, current_best.clone()).await?; let delta = new_best.height - ancestor.height + 1; @@ -362,6 +366,22 @@ impl Relayer { let hash = bitcoin::BlockHash::from_slice(&relayer_blockhash.0)?; Ok(RelayHeader { hash, header, height: height.try_into()? }) } + + async fn get_heaviest_relayed_block_header_regtest(&self) -> Result { + let current_best_digest_raw = self.contract.getBestKnownDigest().call().await?; + let current_best_digest = BlockHash::from_byte_array(current_best_digest_raw.0); + Ok(RelayHeader { + hash: current_best_digest, + header: self.esplora_client.get_block_header(¤t_best_digest).await?, + height: self + .contract + .findHeight(current_best_digest_raw) + .call() + .await? + .try_into() + .expect("height larger than u32::MAX"), + }) + } } #[cfg(test)] From d45f97149133c87079a1092013ec54fb9df300a5 Mon Sep 17 00:00:00 2001 From: nazeh Date: Wed, 11 Jun 2025 12:51:57 +0300 Subject: [PATCH 08/24] feat(relayer): add deploy_contract helper function --- relayer/src/main.rs | 30 ++++++++---------------------- relayer/src/relayer.rs | 26 ++++++++++++++++++++++++++ 2 files changed, 34 insertions(+), 22 deletions(-) diff --git a/relayer/src/main.rs b/relayer/src/main.rs index 64f681ca7..982afc797 100644 --- a/relayer/src/main.rs +++ b/relayer/src/main.rs @@ -52,15 +52,7 @@ async fn main() -> Result<()> { #[cfg(test)] mod tests { use super::*; - use alloy::{ - network::EthereumWallet, - node_bindings::Anvil, - primitives::{Bytes, FixedBytes, U256}, - providers::ProviderBuilder, - signers::local::PrivateKeySigner, - }; - use bindings::fullrelaywithverify::FullRelayWithVerify as BitcoinRelay; - use bitcoin::hashes::Hash; + use alloy::{network::EthereumWallet, node_bindings::Anvil, signers::local::PrivateKeySigner}; #[tokio::test] async fn test() -> Result<()> { @@ -69,24 +61,18 @@ mod tests { let wallet = EthereumWallet::from(signer.clone()); let rpc_url = anvil.endpoint_url(); - let provider = ProviderBuilder::new().wallet(wallet.clone()).connect_http(rpc_url.clone()); - let esplora_client = EsploraClient::new(bitcoin::Network::Bitcoin)?; let period_start_height = 201600; // change this to test different headers let genesis_height = period_start_height + 2014; - let period_start_block_hash = esplora_client.get_block_hash(period_start_height).await?; - let genesis_block_header = esplora_client - .get_raw_block_header(&esplora_client.get_block_hash(genesis_height).await?) - .await?; - - let contract = BitcoinRelay::deploy( - provider.clone(), - Bytes::from(genesis_block_header.clone()), - U256::from(genesis_height), - FixedBytes::new(period_start_block_hash.to_byte_array()), + let contract_address = Relayer::deploy_contract( + &rpc_url, + &wallet, + &esplora_client, + genesis_height, + period_start_height, ) .await?; @@ -103,7 +89,7 @@ mod tests { // assert!(receipt.status()); - Relayer::new(rpc_url, *contract.address(), esplora_client, wallet).run_once().await?; + Relayer::new(rpc_url, contract_address, esplora_client, wallet).run_once().await?; Ok(()) } diff --git a/relayer/src/relayer.rs b/relayer/src/relayer.rs index fd9830218..9b1dd8c7a 100644 --- a/relayer/src/relayer.rs +++ b/relayer/src/relayer.rs @@ -83,6 +83,32 @@ impl Relayer { Self::new(bob_url, relay_address, esplora_client, wallet) } + /// Helper function to deploy relay contract. + pub async fn deploy_contract( + rpc_url: &Url, + wallet: &EthereumWallet, + esplora_client: &EsploraClient, + genesis_height: u32, + period_start_height: u32, + ) -> Result
{ + let provider = ProviderBuilder::new().wallet(wallet.clone()).connect_http(rpc_url.clone()); + + let period_start_block_hash = esplora_client.get_block_hash(period_start_height).await?; + let genesis_block_header = esplora_client + .get_raw_block_header(&esplora_client.get_block_hash(genesis_height).await?) + .await?; + + let contract = BitcoinRelay::deploy( + provider.clone(), + Bytes::from(genesis_block_header.clone()), + U256::from(genesis_height), + FixedBytes::new(period_start_block_hash.to_byte_array()), + ) + .await?; + + Ok(*contract.address()) + } + async fn relayed_height(&self) -> Result { let relayer_blockhash = self.contract.getBestKnownDigest().call().await?; let relayed_height: u32 = From 08d02bb9183eb35212a65d176e7e530f32d1a6a0 Mon Sep 17 00:00:00 2001 From: nazeh Date: Wed, 11 Jun 2025 14:13:28 +0300 Subject: [PATCH 09/24] feat(fullrelay_contract): remove required difficulty --- contracts/src/relay/FullRelay.sol | 5 ----- contracts/test/fullRelay/FullRelayConstructionTest.t.sol | 5 ----- 2 files changed, 10 deletions(-) diff --git a/contracts/src/relay/FullRelay.sol b/contracts/src/relay/FullRelay.sol index b2d99700c..2fca3c768 100644 --- a/contracts/src/relay/FullRelay.sol +++ b/contracts/src/relay/FullRelay.sol @@ -49,11 +49,6 @@ contract FullRelay is IFullRelay { require(isHeaderValidLength(_genesisHeader), "Bad genesis block"); bytes32 _genesisDigest = _genesisHeader.hash256(); - require( - _periodStart & bytes32(0x0000000000000000000000000000000000000000000000000000000000ffffff) == bytes32(0), - "Period start hash does not have work. Hint: wrong byte order?" - ); - relayGenesis = _genesisDigest; bestKnownDigest = _genesisDigest; lastReorgCommonAncestor = _genesisDigest; diff --git a/contracts/test/fullRelay/FullRelayConstructionTest.t.sol b/contracts/test/fullRelay/FullRelayConstructionTest.t.sol index da6f7e071..063d76cac 100644 --- a/contracts/test/fullRelay/FullRelayConstructionTest.t.sol +++ b/contracts/test/fullRelay/FullRelayConstructionTest.t.sol @@ -31,11 +31,6 @@ contract FullRelayConstructionTest is FullRelayTestUtils { relay = new TestRelay("", genesisHeight, orphanDigestLe); } - function testPeriodStartWrongByteOrder() external { - vm.expectRevert(bytes("Period start hash does not have work. Hint: wrong byte order?")); - new TestRelay(genesisHex, genesisHeight, orphanDigestLe); - } - function testStoresGenesisBlockInfo() external view { assertEq(relay.getRelayGenesis(), genesisDigestLe); From 14d0505c73af31c49bd0a134a6e4573f96d0c051 Mon Sep 17 00:00:00 2001 From: nazeh Date: Wed, 11 Jun 2025 14:14:20 +0300 Subject: [PATCH 10/24] chore: bindings --- crates/bindings/src/address.rs | 215 + crates/bindings/src/arbitary_erc20.rs | 4237 +++++++ .../bindings/src/avalon_lending_strategy.rs | 1771 +++ crates/bindings/src/avalon_lst_strategy.rs | 1812 +++ .../avalon_tbtc_lending_strategy_forked.rs | 8013 ++++++++++++ ...=> avalon_wbtc_lending_strategy_forked.rs} | 1484 +-- .../src/avalon_wbtc_lst_strategy_forked.rs | 8004 ++++++++++++ crates/bindings/src/bedrock_strategy.rs | 1554 +++ .../bindings/src/bedrock_strategy_forked.rs | 7991 ++++++++++++ crates/bindings/src/bitcoin_tx.rs | 218 + crates/bindings/src/bitcoin_tx_builder.rs | 1571 +++ crates/bindings/src/btc_market_place.rs | 9865 +++++++++++++++ crates/bindings/src/btc_utils.rs | 1127 ++ crates/bindings/src/bytes_lib.rs | 218 + crates/bindings/src/constants.rs | 218 + crates/bindings/src/context.rs | 215 + .../src/dummy_avalon_pool_implementation.rs | 940 ++ .../src/dummy_bedrock_vault_implementation.rs | 1060 ++ crates/bindings/src/dummy_ionic_pool.rs | 842 ++ crates/bindings/src/dummy_ionic_token.rs | 4713 +++++++ crates/bindings/src/dummy_pell_strategy.rs | 218 + .../src/dummy_pell_strategy_manager.rs | 838 ++ crates/bindings/src/dummy_se_bep20.rs | 5161 ++++++++ crates/bindings/src/dummy_shoe_bill_token.rs | 4696 +++++++ crates/bindings/src/dummy_solv_router.rs | 679 + crates/bindings/src/erc20.rs | 3224 +++++ crates/bindings/src/erc2771_recipient.rs | 735 ++ .../src/forked_strategy_template_tbtc.rs | 7635 ++++++++++++ .../src/forked_strategy_template_wbtc.rs | 7635 ++++++++++++ .../src/{fullrelay.rs => full_relay.rs} | 8 +- ...ithverify.rs => full_relay_with_verify.rs} | 8 +- crates/bindings/src/fullrelayaddheadertest.rs | 9634 --------------- .../src/fullrelayaddheaderwithretargettest.rs | 9635 --------------- .../bindings/src/fullrelayconstructiontest.rs | 8899 -------------- ...layheaviestfromancestorwithretargettest.rs | 8902 -------------- .../src/fullrelayismostancestortest.rs | 9113 -------------- .../bindings/src/fullrelaymarkheaviesttest.rs | 9284 -------------- .../src/fullrelaywithverifydirecttest.rs | 9638 --------------- ...fullrelaywithverifythroughbitcointxtest.rs | 10208 ---------------- ...fullrelaywithverifythroughwitnesstxtest.rs | 9602 --------------- crates/bindings/src/hybrid_btc_strategy.rs | 1788 +++ ....rs => hybrid_btc_strategy_forked_wbtc.rs} | 1863 +-- crates/bindings/src/i_avalon_i_pool.rs | 808 ++ crates/bindings/src/i_bedrock_vault.rs | 924 ++ .../src/{ifullrelay.rs => i_full_relay.rs} | 0 ...hverify.rs => i_full_relay_with_verify.rs} | 0 crates/bindings/src/i_ionic_token.rs | 719 ++ crates/bindings/src/i_light_relay.rs | 2550 ++++ crates/bindings/src/i_pell_strategy.rs | 218 + .../bindings/src/i_pell_strategy_manager.rs | 841 ++ crates/bindings/src/i_pool.rs | 740 ++ crates/bindings/src/i_se_bep20.rs | 1185 ++ crates/bindings/src/i_solv_btc_router.rs | 553 + crates/bindings/src/i_strategy.rs | 782 ++ .../src/i_strategy_with_slippage_args.rs | 1275 ++ crates/bindings/src/i_teller.rs | 547 + crates/bindings/src/ic_erc20.rs | 729 ++ crates/bindings/src/ierc20.rs | 2049 ++++ crates/bindings/src/ierc20_metadata.rs | 2650 ++++ crates/bindings/src/ierc2771_recipient.rs | 527 + crates/bindings/src/ionic_strategy.rs | 1767 +++ crates/bindings/src/ionic_strategy_forked.rs | 7991 ++++++++++++ crates/bindings/src/lib.rs | 101 +- crates/bindings/src/light_relay.rs | 6027 +++++++++ crates/bindings/src/market_place.rs | 3197 +++++ crates/bindings/src/ord_marketplace.rs | 6113 +++++++++ crates/bindings/src/ownable.rs | 1104 ++ ...s => pell_bed_rock_lst_strategy_forked.rs} | 1429 +-- ...st.rs => pell_bed_rock_strategy_forked.rs} | 1445 +-- crates/bindings/src/pell_bedrock_strategy.rs | 1808 +++ crates/bindings/src/pell_solv_lst_strategy.rs | 1808 +++ crates/bindings/src/pell_strategy.rs | 2032 +++ crates/bindings/src/pell_strategy_forked.rs | 7991 ++++++++++++ crates/bindings/src/relay_utils.rs | 218 + crates/bindings/src/safe_erc20.rs | 218 + crates/bindings/src/safe_math.rs | 218 + crates/bindings/src/seg_wit_utils.rs | 723 ++ ...egment_bedrock_and_lst_strategy_forked.rs} | 3094 ++--- .../bindings/src/segment_bedrock_strategy.rs | 1810 +++ .../bindings/src/segment_solv_lst_strategy.rs | 1810 +++ crates/bindings/src/segment_strategy.rs | 1554 +++ .../bindings/src/segment_strategy_forked.rs | 7991 ++++++++++++ crates/bindings/src/shoebill_strategy.rs | 1554 +++ .../src/shoebill_tbtc_strategy_forked.rs | 8006 ++++++++++++ crates/bindings/src/solv_btc_strategy.rs | 2006 +++ crates/bindings/src/solv_lst_strategy.rs | 2695 ++++ ...aytestutils.rs => solv_strategy_forked.rs} | 1875 ++- crates/bindings/src/std_constants.rs | 218 + crates/bindings/src/strings.rs | 215 + crates/bindings/src/utilities.rs | 3808 ++++++ crates/bindings/src/validate_spv.rs | 218 + crates/bindings/src/witness_tx.rs | 218 + relayer/src/relayer.rs | 4 +- 93 files changed, 181310 insertions(+), 92524 deletions(-) create mode 100644 crates/bindings/src/address.rs create mode 100644 crates/bindings/src/arbitary_erc20.rs create mode 100644 crates/bindings/src/avalon_lending_strategy.rs create mode 100644 crates/bindings/src/avalon_lst_strategy.rs create mode 100644 crates/bindings/src/avalon_tbtc_lending_strategy_forked.rs rename crates/bindings/src/{fullrelayisancestortest.rs => avalon_wbtc_lending_strategy_forked.rs} (63%) create mode 100644 crates/bindings/src/avalon_wbtc_lst_strategy_forked.rs create mode 100644 crates/bindings/src/bedrock_strategy.rs create mode 100644 crates/bindings/src/bedrock_strategy_forked.rs create mode 100644 crates/bindings/src/bitcoin_tx.rs create mode 100644 crates/bindings/src/bitcoin_tx_builder.rs create mode 100644 crates/bindings/src/btc_market_place.rs create mode 100644 crates/bindings/src/btc_utils.rs create mode 100644 crates/bindings/src/bytes_lib.rs create mode 100644 crates/bindings/src/constants.rs create mode 100644 crates/bindings/src/context.rs create mode 100644 crates/bindings/src/dummy_avalon_pool_implementation.rs create mode 100644 crates/bindings/src/dummy_bedrock_vault_implementation.rs create mode 100644 crates/bindings/src/dummy_ionic_pool.rs create mode 100644 crates/bindings/src/dummy_ionic_token.rs create mode 100644 crates/bindings/src/dummy_pell_strategy.rs create mode 100644 crates/bindings/src/dummy_pell_strategy_manager.rs create mode 100644 crates/bindings/src/dummy_se_bep20.rs create mode 100644 crates/bindings/src/dummy_shoe_bill_token.rs create mode 100644 crates/bindings/src/dummy_solv_router.rs create mode 100644 crates/bindings/src/erc20.rs create mode 100644 crates/bindings/src/erc2771_recipient.rs create mode 100644 crates/bindings/src/forked_strategy_template_tbtc.rs create mode 100644 crates/bindings/src/forked_strategy_template_wbtc.rs rename crates/bindings/src/{fullrelay.rs => full_relay.rs} (81%) rename crates/bindings/src/{fullrelaywithverify.rs => full_relay_with_verify.rs} (82%) delete mode 100644 crates/bindings/src/fullrelayaddheadertest.rs delete mode 100644 crates/bindings/src/fullrelayaddheaderwithretargettest.rs delete mode 100644 crates/bindings/src/fullrelayconstructiontest.rs delete mode 100644 crates/bindings/src/fullrelayheaviestfromancestorwithretargettest.rs delete mode 100644 crates/bindings/src/fullrelayismostancestortest.rs delete mode 100644 crates/bindings/src/fullrelaymarkheaviesttest.rs delete mode 100644 crates/bindings/src/fullrelaywithverifydirecttest.rs delete mode 100644 crates/bindings/src/fullrelaywithverifythroughbitcointxtest.rs delete mode 100644 crates/bindings/src/fullrelaywithverifythroughwitnesstxtest.rs create mode 100644 crates/bindings/src/hybrid_btc_strategy.rs rename crates/bindings/src/{fullrelaywithverifytest.rs => hybrid_btc_strategy_forked_wbtc.rs} (67%) create mode 100644 crates/bindings/src/i_avalon_i_pool.rs create mode 100644 crates/bindings/src/i_bedrock_vault.rs rename crates/bindings/src/{ifullrelay.rs => i_full_relay.rs} (100%) rename crates/bindings/src/{ifullrelaywithverify.rs => i_full_relay_with_verify.rs} (100%) create mode 100644 crates/bindings/src/i_ionic_token.rs create mode 100644 crates/bindings/src/i_light_relay.rs create mode 100644 crates/bindings/src/i_pell_strategy.rs create mode 100644 crates/bindings/src/i_pell_strategy_manager.rs create mode 100644 crates/bindings/src/i_pool.rs create mode 100644 crates/bindings/src/i_se_bep20.rs create mode 100644 crates/bindings/src/i_solv_btc_router.rs create mode 100644 crates/bindings/src/i_strategy.rs create mode 100644 crates/bindings/src/i_strategy_with_slippage_args.rs create mode 100644 crates/bindings/src/i_teller.rs create mode 100644 crates/bindings/src/ic_erc20.rs create mode 100644 crates/bindings/src/ierc20.rs create mode 100644 crates/bindings/src/ierc20_metadata.rs create mode 100644 crates/bindings/src/ierc2771_recipient.rs create mode 100644 crates/bindings/src/ionic_strategy.rs create mode 100644 crates/bindings/src/ionic_strategy_forked.rs create mode 100644 crates/bindings/src/light_relay.rs create mode 100644 crates/bindings/src/market_place.rs create mode 100644 crates/bindings/src/ord_marketplace.rs create mode 100644 crates/bindings/src/ownable.rs rename crates/bindings/src/{fullrelayfindheighttest.rs => pell_bed_rock_lst_strategy_forked.rs} (63%) rename crates/bindings/src/{fullrelayfindancestortest.rs => pell_bed_rock_strategy_forked.rs} (63%) create mode 100644 crates/bindings/src/pell_bedrock_strategy.rs create mode 100644 crates/bindings/src/pell_solv_lst_strategy.rs create mode 100644 crates/bindings/src/pell_strategy.rs create mode 100644 crates/bindings/src/pell_strategy_forked.rs create mode 100644 crates/bindings/src/relay_utils.rs create mode 100644 crates/bindings/src/safe_erc20.rs create mode 100644 crates/bindings/src/safe_math.rs create mode 100644 crates/bindings/src/seg_wit_utils.rs rename crates/bindings/src/{fullrelayheaviestfromancestortest.rs => segment_bedrock_and_lst_strategy_forked.rs} (56%) create mode 100644 crates/bindings/src/segment_bedrock_strategy.rs create mode 100644 crates/bindings/src/segment_solv_lst_strategy.rs create mode 100644 crates/bindings/src/segment_strategy.rs create mode 100644 crates/bindings/src/segment_strategy_forked.rs create mode 100644 crates/bindings/src/shoebill_strategy.rs create mode 100644 crates/bindings/src/shoebill_tbtc_strategy_forked.rs create mode 100644 crates/bindings/src/solv_btc_strategy.rs create mode 100644 crates/bindings/src/solv_lst_strategy.rs rename crates/bindings/src/{fullrelaytestutils.rs => solv_strategy_forked.rs} (67%) create mode 100644 crates/bindings/src/std_constants.rs create mode 100644 crates/bindings/src/strings.rs create mode 100644 crates/bindings/src/utilities.rs create mode 100644 crates/bindings/src/validate_spv.rs create mode 100644 crates/bindings/src/witness_tx.rs diff --git a/crates/bindings/src/address.rs b/crates/bindings/src/address.rs new file mode 100644 index 000000000..985c80231 --- /dev/null +++ b/crates/bindings/src/address.rs @@ -0,0 +1,215 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface Address {} +``` + +...which was generated by the following JSON ABI: +```json +[] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod Address { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122066b802c23a5c4d43f9b40fc6e1048fe03bb91dfb723ee13b98711fa15c7165a364736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`U`2`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`&WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 f\xB8\x02\xC2:\\MC\xF9\xB4\x0F\xC6\xE1\x04\x8F\xE0;\xB9\x1D\xFBr>\xE1;\x98q\x1F\xA1\\qe\xA3dsolcC\0\x08\x1C\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122066b802c23a5c4d43f9b40fc6e1048fe03bb91dfb723ee13b98711fa15c7165a364736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 f\xB8\x02\xC2:\\MC\xF9\xB4\x0F\xC6\xE1\x04\x8F\xE0;\xB9\x1D\xFBr>\xE1;\x98q\x1F\xA1\\qe\xA3dsolcC\0\x08\x1C\x003", + ); + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`Address`](self) contract instance. + +See the [wrapper's documentation](`AddressInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >(address: alloy_sol_types::private::Address, provider: P) -> AddressInstance { + AddressInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + AddressInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + AddressInstance::::deploy_builder(provider) + } + /**A [`Address`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`Address`](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 AddressInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for AddressInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("AddressInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > AddressInstance { + /**Creates a new wrapper around an on-chain [`Address`](self) contract instance. + +See the [wrapper's documentation](`AddressInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 AddressInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> AddressInstance { + AddressInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > AddressInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > AddressInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/arbitary_erc20.rs b/crates/bindings/src/arbitary_erc20.rs new file mode 100644 index 000000000..3b5ebe881 --- /dev/null +++ b/crates/bindings/src/arbitary_erc20.rs @@ -0,0 +1,4237 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface ArbitaryErc20 { + event Approval(address indexed owner, address indexed spender, uint256 value); + event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); + 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 owner() external view returns (address); + function renounceOwnership() external; + function sudoMint(address to, uint256 amount) external; + function symbol() external view returns (string memory); + function totalSupply() external view returns (uint256); + function transfer(address to, uint256 amount) external returns (bool); + function transferFrom(address from, address to, uint256 amount) external returns (bool); + function transferOwnership(address newOwner) external; +} +``` + +...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": "owner", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "renounceOwnership", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "sudoMint", + "inputs": [ + { + "name": "to", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "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": "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" + }, + { + "type": "function", + "name": "transferOwnership", + "inputs": [ + { + "name": "newOwner", + "type": "address", + "internalType": "address" + } + ], + "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": "OwnershipTransferred", + "inputs": [ + { + "name": "previousOwner", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "newOwner", + "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 ArbitaryErc20 { + use super::*; + use alloy::sol_types as 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__\xFD[P`@Qa\x10#8\x03\x80a\x10#\x839\x81\x01`@\x81\x90Ra\0.\x91a\x01[V[\x81\x81`\x03a\0<\x83\x82a\x02DV[P`\x04a\0I\x82\x82a\x02DV[PPPa\0ba\0]a\0i` \x1B` \x1CV[a\0mV[PPa\x02\xFEV[3\x90V[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x01`\x01`\xA0\x1B\x03\x19\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x82`\x1F\x83\x01\x12a\0\xE1W__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\0\xFAWa\0\xFAa\0\xBEV[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x01(Wa\x01(a\0\xBEV[`@R\x81\x81R\x83\x82\x01` \x01\x85\x10\x15a\x01?W__\xFD[\x81` \x85\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[__`@\x83\x85\x03\x12\x15a\x01lW__\xFD[\x82Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\x81W__\xFD[a\x01\x8D\x85\x82\x86\x01a\0\xD2V[` \x85\x01Q\x90\x93P\x90P`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\xAAW__\xFD[a\x01\xB6\x85\x82\x86\x01a\0\xD2V[\x91PP\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x01\xD4W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x01\xF2WcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\x02?W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x02\x1DWP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x02\x14a\x02\nW\x80c\xF2\xFD\xE3\x8B\x14a\x02BW__\xFD[\x80cp\xA0\x821\x14a\x01\x91W\x80cqP\x18\xA6\x14a\x01\xB9W\x80c\x8D\xA5\xCB[\x14a\x01\xC1W\x80c\x95\xD8\x9BA\x14a\x01\xDCW__\xFD[\x80c#\xB8r\xDD\x11a\0\xCEW\x80c#\xB8r\xDD\x14a\x01GW\x80c-h\x8C\xA8\x14a\x01ZW\x80c1<\xE5g\x14a\x01oW\x80c9P\x93Q\x14a\x01~W__\xFD[\x80c\x06\xFD\xDE\x03\x14a\0\xF4W\x80c\t^\xA7\xB3\x14a\x01\x12W\x80c\x18\x16\r\xDD\x14a\x015W[__\xFD[a\0\xFCa\x02UV[`@Qa\x01\t\x91\x90a\x0B8V[`@Q\x80\x91\x03\x90\xF3[a\x01%a\x01 6`\x04a\x0B\xA6V[a\x02\xE5V[`@Q\x90\x15\x15\x81R` \x01a\x01\tV[`\x02T[`@Q\x90\x81R` \x01a\x01\tV[a\x01%a\x01U6`\x04a\x0B\xCEV[a\x02\xFEV[a\x01ma\x01h6`\x04a\x0B\xA6V[a\x03!V[\0[`@Q`\x12\x81R` \x01a\x01\tV[a\x01%a\x01\x8C6`\x04a\x0B\xA6V[a\x03\x8EV[a\x019a\x01\x9F6`\x04a\x0C\x08V[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R` \x81\x90R`@\x90 T\x90V[a\x01ma\x03\xCCV[`\x05T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01\tV[a\0\xFCa\x041V[a\x01%a\x01\xF26`\x04a\x0B\xA6V[a\x04@V[a\x01%a\x02\x056`\x04a\x0B\xA6V[a\x04\xE9V[a\x019a\x02\x186`\x04a\x0C(V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[a\x01ma\x02P6`\x04a\x0C\x08V[a\x04\xF6V[```\x03\x80Ta\x02d\x90a\x0CYV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\x90\x90a\x0CYV[\x80\x15a\x02\xDBW\x80`\x1F\x10a\x02\xB2Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02\xDBV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02\xBEW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[_3a\x02\xF2\x81\x85\x85a\x05\xD8V[`\x01\x91PP[\x92\x91PPV[_3a\x03\x0B\x85\x82\x85a\x07/V[a\x03\x16\x85\x85\x85a\x07\xDEV[P`\x01\x94\x93PPPPV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x03\x80W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\x8A\x82\x82a\t\xF3V[PPV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90a\x02\xF2\x90\x82\x90\x86\x90a\x03\xC7\x90\x87\x90a\x0C\xAAV[a\x05\xD8V[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x04&W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03wV[a\x04/_a\n\xCFV[V[```\x04\x80Ta\x02d\x90a\x0CYV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90\x83\x81\x10\x15a\x04\xDCW`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[a\x03\x16\x82\x86\x86\x84\x03a\x05\xD8V[_3a\x02\xF2\x81\x85\x85a\x07\xDEV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x05PW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03wV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x05\xCCW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01R\x7Fddress\0\0\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\x03wV[a\x05\xD5\x81a\n\xCFV[PV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x06SW`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x06\xCFW`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\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[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R 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\x81\x14a\x07\xD8W\x81\x81\x10\x15a\x07\xCBW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FERC20: insufficient allowance\0\0\0`D\x82\x01R`d\x01a\x03wV[a\x07\xD8\x84\x84\x84\x84\x03a\x05\xD8V[PPPPV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x08ZW`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x08\xD6W`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R` \x81\x90R`@\x90 T\x81\x81\x10\x15a\tdW`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16_\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R\x90\x81 \x80T\x84\x92\x90a\t\x9A\x90\x84\x90a\x0C\xAAV[\x92PP\x81\x90UP\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\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\t\xE6\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3a\x07\xD8V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\nIW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FERC20: mint to the zero address\0`D\x82\x01R`d\x01a\x03wV[\x80`\x02_\x82\x82Ta\nZ\x91\x90a\x0C\xAAV[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x83\x92\x90a\n\x86\x90\x84\x90a\x0C\xAAV[\x90\x91UPP`@Q\x81\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90_\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[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\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\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\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\x84\x01\x01\x91PP\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0B\xA1W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0B\xB7W__\xFD[a\x0B\xC0\x83a\x0B\x8BV[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x0B\xE0W__\xFD[a\x0B\xE9\x84a\x0B\x8BV[\x92Pa\x0B\xF7` \x85\x01a\x0B\x8BV[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\x0C\x18W__\xFD[a\x0C!\x82a\x0B\x8BV[\x93\x92PPPV[__`@\x83\x85\x03\x12\x15a\x0C9W__\xFD[a\x0CB\x83a\x0B\x8BV[\x91Pa\x0CP` \x84\x01a\x0B\x8BV[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x0CmW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x0C\xA4W\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[P\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02\xF8W\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\xFE\xA2dipfsX\"\x12 6bhE\x12\x8Ff\xB6f-^\xA0\xFB}\xA1\x12\x14a\x02\nW\x80c\xF2\xFD\xE3\x8B\x14a\x02BW__\xFD[\x80cp\xA0\x821\x14a\x01\x91W\x80cqP\x18\xA6\x14a\x01\xB9W\x80c\x8D\xA5\xCB[\x14a\x01\xC1W\x80c\x95\xD8\x9BA\x14a\x01\xDCW__\xFD[\x80c#\xB8r\xDD\x11a\0\xCEW\x80c#\xB8r\xDD\x14a\x01GW\x80c-h\x8C\xA8\x14a\x01ZW\x80c1<\xE5g\x14a\x01oW\x80c9P\x93Q\x14a\x01~W__\xFD[\x80c\x06\xFD\xDE\x03\x14a\0\xF4W\x80c\t^\xA7\xB3\x14a\x01\x12W\x80c\x18\x16\r\xDD\x14a\x015W[__\xFD[a\0\xFCa\x02UV[`@Qa\x01\t\x91\x90a\x0B8V[`@Q\x80\x91\x03\x90\xF3[a\x01%a\x01 6`\x04a\x0B\xA6V[a\x02\xE5V[`@Q\x90\x15\x15\x81R` \x01a\x01\tV[`\x02T[`@Q\x90\x81R` \x01a\x01\tV[a\x01%a\x01U6`\x04a\x0B\xCEV[a\x02\xFEV[a\x01ma\x01h6`\x04a\x0B\xA6V[a\x03!V[\0[`@Q`\x12\x81R` \x01a\x01\tV[a\x01%a\x01\x8C6`\x04a\x0B\xA6V[a\x03\x8EV[a\x019a\x01\x9F6`\x04a\x0C\x08V[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R` \x81\x90R`@\x90 T\x90V[a\x01ma\x03\xCCV[`\x05T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01\tV[a\0\xFCa\x041V[a\x01%a\x01\xF26`\x04a\x0B\xA6V[a\x04@V[a\x01%a\x02\x056`\x04a\x0B\xA6V[a\x04\xE9V[a\x019a\x02\x186`\x04a\x0C(V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[a\x01ma\x02P6`\x04a\x0C\x08V[a\x04\xF6V[```\x03\x80Ta\x02d\x90a\x0CYV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\x90\x90a\x0CYV[\x80\x15a\x02\xDBW\x80`\x1F\x10a\x02\xB2Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02\xDBV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02\xBEW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[_3a\x02\xF2\x81\x85\x85a\x05\xD8V[`\x01\x91PP[\x92\x91PPV[_3a\x03\x0B\x85\x82\x85a\x07/V[a\x03\x16\x85\x85\x85a\x07\xDEV[P`\x01\x94\x93PPPPV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x03\x80W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\x8A\x82\x82a\t\xF3V[PPV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90a\x02\xF2\x90\x82\x90\x86\x90a\x03\xC7\x90\x87\x90a\x0C\xAAV[a\x05\xD8V[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x04&W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03wV[a\x04/_a\n\xCFV[V[```\x04\x80Ta\x02d\x90a\x0CYV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90\x83\x81\x10\x15a\x04\xDCW`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[a\x03\x16\x82\x86\x86\x84\x03a\x05\xD8V[_3a\x02\xF2\x81\x85\x85a\x07\xDEV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x05PW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03wV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x05\xCCW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01R\x7Fddress\0\0\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\x03wV[a\x05\xD5\x81a\n\xCFV[PV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x06SW`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x06\xCFW`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\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[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R 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\x81\x14a\x07\xD8W\x81\x81\x10\x15a\x07\xCBW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FERC20: insufficient allowance\0\0\0`D\x82\x01R`d\x01a\x03wV[a\x07\xD8\x84\x84\x84\x84\x03a\x05\xD8V[PPPPV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x08ZW`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x08\xD6W`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R` \x81\x90R`@\x90 T\x81\x81\x10\x15a\tdW`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16_\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R\x90\x81 \x80T\x84\x92\x90a\t\x9A\x90\x84\x90a\x0C\xAAV[\x92PP\x81\x90UP\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\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\t\xE6\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3a\x07\xD8V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\nIW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FERC20: mint to the zero address\0`D\x82\x01R`d\x01a\x03wV[\x80`\x02_\x82\x82Ta\nZ\x91\x90a\x0C\xAAV[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x83\x92\x90a\n\x86\x90\x84\x90a\x0C\xAAV[\x90\x91UPP`@Q\x81\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90_\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[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\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\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\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\x84\x01\x01\x91PP\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0B\xA1W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0B\xB7W__\xFD[a\x0B\xC0\x83a\x0B\x8BV[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x0B\xE0W__\xFD[a\x0B\xE9\x84a\x0B\x8BV[\x92Pa\x0B\xF7` \x85\x01a\x0B\x8BV[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\x0C\x18W__\xFD[a\x0C!\x82a\x0B\x8BV[\x93\x92PPPV[__`@\x83\x85\x03\x12\x15a\x0C9W__\xFD[a\x0CB\x83a\x0B\x8BV[\x91Pa\x0CP` \x84\x01a\x0B\x8BV[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x0CmW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x0C\xA4W\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[P\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02\xF8W\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\xFE\xA2dipfsX\"\x12 6bhE\x12\x8Ff\xB6f-^\xA0\xFB}\xA1\x12 = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + 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, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + owner: topics.1, + spender: topics.2, + value: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.value), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.owner, + ); + out[2usize] = ::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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for OwnershipTransferred { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + 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, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + previousOwner: topics.1, + newOwner: topics.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return 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) -> ::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() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.previousOwner, + ); + out[2usize] = ::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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Transfer { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + 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, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + from: topics.1, + to: topics.2, + value: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.value), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.from, + ); + out[2usize] = ::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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value.name_, value.symbol_) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.name_, + ), + ::tokenize( + &self.symbol_, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: allowanceCall) -> Self { + (value.owner, value.spender) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for allowanceCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + owner: tuple.0, + spender: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: allowanceReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "allowance(address,address)"; + const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.owner, + ), + ::tokenize( + &self.spender, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: allowanceReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: approveCall) -> Self { + (value.spender, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for approveCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + spender: tuple.0, + amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: approveReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "approve(address,uint256)"; + const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.spender, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: approveReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: balanceOfCall) -> Self { + (value.account,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for balanceOfCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { account: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: balanceOfReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "balanceOf(address)"; + const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.account, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: balanceOfReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: decimalsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for decimalsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: decimalsReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for decimalsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for decimalsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = u8; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "decimals()"; + const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: decimalsReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: decreaseAllowanceCall) -> Self { + (value.spender, value.subtractedValue) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for decreaseAllowanceCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + spender: tuple.0, + subtractedValue: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: decreaseAllowanceReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)"; + const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.spender, + ), + as alloy_sol_types::SolType>::tokenize(&self.subtractedValue), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: decreaseAllowanceReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: increaseAllowanceCall) -> Self { + (value.spender, value.addedValue) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for increaseAllowanceCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + spender: tuple.0, + addedValue: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: increaseAllowanceReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "increaseAllowance(address,uint256)"; + const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.spender, + ), + as alloy_sol_types::SolType>::tokenize(&self.addedValue), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: increaseAllowanceReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: nameCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for nameCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: nameReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for nameReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for nameCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::String; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "name()"; + const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: nameReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ownerCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ownerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ownerReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ownerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for ownerCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "owner()"; + const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: ownerReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: renounceOwnershipCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for renounceOwnershipCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: renounceOwnershipReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for renounceOwnershipReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl renounceOwnershipReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for renounceOwnershipCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = renounceOwnershipReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "renounceOwnership()"; + const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8]; + #[inline] + fn new<'a>( + tuple: 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 { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `sudoMint(address,uint256)` and selector `0x2d688ca8`. +```solidity +function sudoMint(address to, uint256 amount) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct sudoMintCall { + #[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 [`sudoMint(address,uint256)`](sudoMintCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct sudoMintReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: sudoMintCall) -> Self { + (value.to, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for sudoMintCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + to: tuple.0, + amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: sudoMintReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for sudoMintReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl sudoMintReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for sudoMintCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = sudoMintReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "sudoMint(address,uint256)"; + const SELECTOR: [u8; 4] = [45u8, 104u8, 140u8, 168u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.to, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + sudoMintReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: symbolCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for symbolCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: symbolReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for symbolReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for symbolCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::String; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "symbol()"; + const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: symbolReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: totalSupplyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for totalSupplyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: totalSupplyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for totalSupplyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for totalSupplyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "totalSupply()"; + const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: totalSupplyReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferCall) -> Self { + (value.to, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for transferCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + to: tuple.0, + amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transfer(address,uint256)"; + const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.to, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: transferReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferFromCall) -> Self { + (value.from, value.to, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for transferFromCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + from: tuple.0, + to: tuple.1, + amount: tuple.2, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferFromReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transferFrom(address,address,uint256)"; + const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.from, + ), + ::tokenize( + &self.to, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: transferFromReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: transferOwnershipCall) -> Self { + (value.newOwner,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for transferOwnershipCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { newOwner: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: transferOwnershipReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for transferOwnershipReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl transferOwnershipReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for transferOwnershipCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = transferOwnershipReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transferOwnership(address)"; + const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::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 { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + ///Container for all the [`ArbitaryErc20`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum ArbitaryErc20Calls { + #[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)] + owner(ownerCall), + #[allow(missing_docs)] + renounceOwnership(renounceOwnershipCall), + #[allow(missing_docs)] + sudoMint(sudoMintCall), + #[allow(missing_docs)] + symbol(symbolCall), + #[allow(missing_docs)] + totalSupply(totalSupplyCall), + #[allow(missing_docs)] + transfer(transferCall), + #[allow(missing_docs)] + transferFrom(transferFromCall), + #[allow(missing_docs)] + transferOwnership(transferOwnershipCall), + } + #[automatically_derived] + impl ArbitaryErc20Calls { + /// 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], + [45u8, 104u8, 140u8, 168u8], + [49u8, 60u8, 229u8, 103u8], + [57u8, 80u8, 147u8, 81u8], + [112u8, 160u8, 130u8, 49u8], + [113u8, 80u8, 24u8, 166u8], + [141u8, 165u8, 203u8, 91u8], + [149u8, 216u8, 155u8, 65u8], + [164u8, 87u8, 194u8, 215u8], + [169u8, 5u8, 156u8, 187u8], + [221u8, 98u8, 237u8, 62u8], + [242u8, 253u8, 227u8, 139u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for ArbitaryErc20Calls { + const NAME: &'static str = "ArbitaryErc20Calls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 15usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::allowance(_) => { + ::SELECTOR + } + Self::approve(_) => ::SELECTOR, + Self::balanceOf(_) => { + ::SELECTOR + } + Self::decimals(_) => ::SELECTOR, + Self::decreaseAllowance(_) => { + ::SELECTOR + } + Self::increaseAllowance(_) => { + ::SELECTOR + } + Self::name(_) => ::SELECTOR, + Self::owner(_) => ::SELECTOR, + Self::renounceOwnership(_) => { + ::SELECTOR + } + Self::sudoMint(_) => ::SELECTOR, + Self::symbol(_) => ::SELECTOR, + Self::totalSupply(_) => { + ::SELECTOR + } + Self::transfer(_) => ::SELECTOR, + Self::transferFrom(_) => { + ::SELECTOR + } + Self::transferOwnership(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn name(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ArbitaryErc20Calls::name) + } + name + }, + { + fn approve( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ArbitaryErc20Calls::approve) + } + approve + }, + { + fn totalSupply( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ArbitaryErc20Calls::totalSupply) + } + totalSupply + }, + { + fn transferFrom( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ArbitaryErc20Calls::transferFrom) + } + transferFrom + }, + { + fn sudoMint( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ArbitaryErc20Calls::sudoMint) + } + sudoMint + }, + { + fn decimals( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ArbitaryErc20Calls::decimals) + } + decimals + }, + { + fn increaseAllowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ArbitaryErc20Calls::increaseAllowance) + } + increaseAllowance + }, + { + fn balanceOf( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ArbitaryErc20Calls::balanceOf) + } + balanceOf + }, + { + fn renounceOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ArbitaryErc20Calls::renounceOwnership) + } + renounceOwnership + }, + { + fn owner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ArbitaryErc20Calls::owner) + } + owner + }, + { + fn symbol( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ArbitaryErc20Calls::symbol) + } + symbol + }, + { + fn decreaseAllowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ArbitaryErc20Calls::decreaseAllowance) + } + decreaseAllowance + }, + { + fn transfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ArbitaryErc20Calls::transfer) + } + transfer + }, + { + fn allowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ArbitaryErc20Calls::allowance) + } + allowance + }, + { + fn transferOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ArbitaryErc20Calls::transferOwnership) + } + transferOwnership + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn name(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ArbitaryErc20Calls::name) + } + name + }, + { + fn approve( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ArbitaryErc20Calls::approve) + } + approve + }, + { + fn totalSupply( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ArbitaryErc20Calls::totalSupply) + } + totalSupply + }, + { + fn transferFrom( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ArbitaryErc20Calls::transferFrom) + } + transferFrom + }, + { + fn sudoMint( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ArbitaryErc20Calls::sudoMint) + } + sudoMint + }, + { + fn decimals( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ArbitaryErc20Calls::decimals) + } + decimals + }, + { + fn increaseAllowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ArbitaryErc20Calls::increaseAllowance) + } + increaseAllowance + }, + { + fn balanceOf( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ArbitaryErc20Calls::balanceOf) + } + balanceOf + }, + { + fn renounceOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ArbitaryErc20Calls::renounceOwnership) + } + renounceOwnership + }, + { + fn owner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ArbitaryErc20Calls::owner) + } + owner + }, + { + fn symbol( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ArbitaryErc20Calls::symbol) + } + symbol + }, + { + fn decreaseAllowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ArbitaryErc20Calls::decreaseAllowance) + } + decreaseAllowance + }, + { + fn transfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ArbitaryErc20Calls::transfer) + } + transfer + }, + { + fn allowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ArbitaryErc20Calls::allowance) + } + allowance + }, + { + fn transferOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ArbitaryErc20Calls::transferOwnership) + } + transferOwnership + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::allowance(inner) => { + ::abi_encoded_size(inner) + } + Self::approve(inner) => { + ::abi_encoded_size(inner) + } + Self::balanceOf(inner) => { + ::abi_encoded_size(inner) + } + Self::decimals(inner) => { + ::abi_encoded_size(inner) + } + Self::decreaseAllowance(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::increaseAllowance(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::name(inner) => { + ::abi_encoded_size(inner) + } + Self::owner(inner) => { + ::abi_encoded_size(inner) + } + Self::renounceOwnership(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::sudoMint(inner) => { + ::abi_encoded_size(inner) + } + Self::symbol(inner) => { + ::abi_encoded_size(inner) + } + Self::totalSupply(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::transfer(inner) => { + ::abi_encoded_size(inner) + } + Self::transferFrom(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::transferOwnership(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::allowance(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::approve(inner) => { + ::abi_encode_raw(inner, out) + } + Self::balanceOf(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::decimals(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::decreaseAllowance(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::increaseAllowance(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::name(inner) => { + ::abi_encode_raw(inner, out) + } + Self::owner(inner) => { + ::abi_encode_raw(inner, out) + } + Self::renounceOwnership(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::sudoMint(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::symbol(inner) => { + ::abi_encode_raw(inner, out) + } + Self::totalSupply(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transfer(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transferFrom(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transferOwnership(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`ArbitaryErc20`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum ArbitaryErc20Events { + #[allow(missing_docs)] + Approval(Approval), + #[allow(missing_docs)] + OwnershipTransferred(OwnershipTransferred), + #[allow(missing_docs)] + Transfer(Transfer), + } + #[automatically_derived] + impl ArbitaryErc20Events { + /// 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]] = &[ + [ + 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, 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, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for ArbitaryErc20Events { + const NAME: &'static str = "ArbitaryErc20Events"; + const COUNT: usize = 3usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Approval) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::OwnershipTransferred) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Transfer) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 ArbitaryErc20Events { + 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::OwnershipTransferred(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::OwnershipTransferred(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 as alloy_contract; + /**Creates a new wrapper around an on-chain [`ArbitaryErc20`](self) contract instance. + +See the [wrapper's documentation](`ArbitaryErc20Instance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> ArbitaryErc20Instance { + ArbitaryErc20Instance::::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: alloy_contract::private::Network, + >( + provider: P, + name_: alloy::sol_types::private::String, + symbol_: alloy::sol_types::private::String, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + ArbitaryErc20Instance::::deploy(provider, name_, symbol_) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + name_: alloy::sol_types::private::String, + symbol_: alloy::sol_types::private::String, + ) -> alloy_contract::RawCallBuilder { + ArbitaryErc20Instance::::deploy_builder(provider, name_, symbol_) + } + /**A [`ArbitaryErc20`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`ArbitaryErc20`](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 ArbitaryErc20Instance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for ArbitaryErc20Instance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("ArbitaryErc20Instance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ArbitaryErc20Instance { + /**Creates a new wrapper around an on-chain [`ArbitaryErc20`](self) contract instance. + +See the [wrapper's documentation](`ArbitaryErc20Instance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + name_: alloy::sol_types::private::String, + symbol_: alloy::sol_types::private::String, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(provider, name_, symbol_); + 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, + name_: alloy::sol_types::private::String, + symbol_: alloy::sol_types::private::String, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { name_, symbol_ }, + )[..], + ] + .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 ArbitaryErc20Instance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> ArbitaryErc20Instance { + ArbitaryErc20Instance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ArbitaryErc20Instance { + /// 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( + &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 [`owner`] function. + pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> { + self.call_builder(&ownerCall) + } + ///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 [`sudoMint`] function. + pub fn sudoMint( + &self, + to: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, sudoMintCall, N> { + self.call_builder(&sudoMintCall { to, amount }) + } + ///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, + 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, + }, + ) + } + ///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. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ArbitaryErc20Instance { + /// 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( + &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::() + } + ///Creates a new event filter for the [`OwnershipTransferred`] event. + pub fn OwnershipTransferred_filter( + &self, + ) -> alloy_contract::Event<&P, OwnershipTransferred, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`Transfer`] event. + pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/avalon_lending_strategy.rs b/crates/bindings/src/avalon_lending_strategy.rs new file mode 100644 index 000000000..fbe8267ea --- /dev/null +++ b/crates/bindings/src/avalon_lending_strategy.rs @@ -0,0 +1,1771 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface AvalonLendingStrategy { + struct StrategySlippageArgs { + uint256 amountOutMin; + } + + event TokenOutput(address tokenReceived, uint256 amountOut); + + constructor(address _avBep20, address _pool); + + function avBep20() external view returns (address); + function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; + function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; + function pool() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_avBep20", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "_pool", + "type": "address", + "internalType": "contract IAvalonIPool" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "avBep20", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IERC20" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "handleGatewayMessage", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "message", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessageWithSlippageArgs", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "args", + "type": "tuple", + "internalType": "struct StrategySlippageArgs", + "components": [ + { + "name": "amountOutMin", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "pool", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IAvalonIPool" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "TokenOutput", + "inputs": [ + { + "name": "tokenReceived", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "amountOut", + "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 AvalonLendingStrategy { + use super::*; + use alloy::sol_types as 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\r\x1E8\x03\x80a\r\x1E\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CHa\0\xD6_9_\x81\x81`S\x01R\x81\x81a\x01U\x01Ra\x02\x89\x01R_\x81\x81`\xA3\x01R\x81\x81a\x01\xC1\x01R\x81\x81a\x03(\x01Ra\x04b\x01Ra\x0CH_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x16\xF0\x11[\x14a\0NW\x80c%\xE2\xD6%\x14a\0\x9EW\x80cPcL\x0E\x14a\0\xC5W\x80c\x7F\x81O5\x14a\0\xDAW[__\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\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[a\0\xD8a\0\xD36`\x04a\t\xCEV[a\0\xEDV[\0[a\0\xD8a\0\xE86`\x04a\n\x90V[a\x01\x17V[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x14V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xBFV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x83V[`@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\x83\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B8V[`@Q\x7Fa{\xA07\0\0\0\0\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`$\x82\x01\x87\x90R\x85\x81\x16`D\x83\x01R_`d\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\x90ca{\xA07\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\xCCW__\xFD[PZ\xF1\x15\x80\x15a\x02\xDEW=__>=_\xFD[PP`@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\x86\x81\x16`\x04\x83\x01R_\x93P\x7F\0\0\0\0\0\0\0\0\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\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03nW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x92\x91\x90a\x0B8V[\x90P\x81\x81\x11a\x03\xE8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x03\xF3\x83\x83a\x0B|V[\x84Q\x90\x91P\x81\x10\x15a\x04GW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xDFV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05}\x90\x85\x90\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\x90`\x84\x01[`@\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~V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1B\x91\x90a\x0B8V[a\x06%\x91\x90a\x0B\x95V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05}\x90\x85\x90\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\x90`d\x01a\x05\x19V[_a\x06\xDF\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\x07t\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07oW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFD\x91\x90a\x0B\xA8V[a\x07oW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[PPPV[``a\x07\x82\x84\x84_\x85a\x07\x8CV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\x04W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08hW`@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\x03\xDFV[__\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\x08\x90\x91\x90a\x0B\xC7V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xCAW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xCFV[``\x91P[P\x91P\x91Pa\x08\xDF\x82\x82\x86a\x08\xEAV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xF9WP\x81a\x07\x85V[\x82Q\x15a\t\tW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xDF\x91\x90a\x0B\xDDV[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\tDW__\xFD[PV[\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\x97Wa\t\x97a\tGV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC6Wa\t\xC6a\tGV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE1W__\xFD[\x845a\t\xEC\x81a\t#V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x03\x81a\t#V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x1EW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n.W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nHWa\nHa\tGV[a\n[` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9DV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\noW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA4W__\xFD[\x855a\n\xAF\x81a\t#V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC6\x81a\t#V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF7W__\xFD[Pa\x0B\0a\ttV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B%W__\xFD[Pa\x0B.a\ttV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BHW__\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[\x81\x81\x03\x81\x81\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[_` \x82\x84\x03\x12\x15a\x0B\xB8W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x85W__\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\xFE\xA2dipfsX\"\x12 \x82\xCFY\x81d\x94k\x8Fq\x9CM\x82\xEF^\xF6\x0E=\xDAW\xBE\xC7=\xE3\xE8\x87\xB6ny\x0B\xF7WqdsolcC\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\x16\xF0\x11[\x14a\0NW\x80c%\xE2\xD6%\x14a\0\x9EW\x80cPcL\x0E\x14a\0\xC5W\x80c\x7F\x81O5\x14a\0\xDAW[__\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\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[a\0\xD8a\0\xD36`\x04a\t\xCEV[a\0\xEDV[\0[a\0\xD8a\0\xE86`\x04a\n\x90V[a\x01\x17V[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x14V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xBFV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x83V[`@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\x83\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B8V[`@Q\x7Fa{\xA07\0\0\0\0\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`$\x82\x01\x87\x90R\x85\x81\x16`D\x83\x01R_`d\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\x90ca{\xA07\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\xCCW__\xFD[PZ\xF1\x15\x80\x15a\x02\xDEW=__>=_\xFD[PP`@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\x86\x81\x16`\x04\x83\x01R_\x93P\x7F\0\0\0\0\0\0\0\0\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\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03nW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x92\x91\x90a\x0B8V[\x90P\x81\x81\x11a\x03\xE8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x03\xF3\x83\x83a\x0B|V[\x84Q\x90\x91P\x81\x10\x15a\x04GW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xDFV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05}\x90\x85\x90\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\x90`\x84\x01[`@\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~V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1B\x91\x90a\x0B8V[a\x06%\x91\x90a\x0B\x95V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05}\x90\x85\x90\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\x90`d\x01a\x05\x19V[_a\x06\xDF\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\x07t\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07oW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFD\x91\x90a\x0B\xA8V[a\x07oW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[PPPV[``a\x07\x82\x84\x84_\x85a\x07\x8CV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\x04W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08hW`@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\x03\xDFV[__\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\x08\x90\x91\x90a\x0B\xC7V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xCAW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xCFV[``\x91P[P\x91P\x91Pa\x08\xDF\x82\x82\x86a\x08\xEAV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xF9WP\x81a\x07\x85V[\x82Q\x15a\t\tW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xDF\x91\x90a\x0B\xDDV[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\tDW__\xFD[PV[\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\x97Wa\t\x97a\tGV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC6Wa\t\xC6a\tGV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE1W__\xFD[\x845a\t\xEC\x81a\t#V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x03\x81a\t#V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x1EW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n.W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nHWa\nHa\tGV[a\n[` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9DV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\noW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA4W__\xFD[\x855a\n\xAF\x81a\t#V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC6\x81a\t#V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF7W__\xFD[Pa\x0B\0a\ttV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B%W__\xFD[Pa\x0B.a\ttV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BHW__\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[\x81\x81\x03\x81\x81\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[_` \x82\x84\x03\x12\x15a\x0B\xB8W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x85W__\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\xFE\xA2dipfsX\"\x12 \x82\xCFY\x81d\x94k\x8Fq\x9CM\x82\xEF^\xF6\x0E=\xDAW\xBE\xC7=\xE3\xE8\x87\xB6ny\x0B\xF7WqdsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct StrategySlippageArgs { uint256 amountOutMin; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct StrategySlippageArgs { + #[allow(missing_docs)] + pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: StrategySlippageArgs) -> Self { + (value.amountOutMin,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for StrategySlippageArgs { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { amountOutMin: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for StrategySlippageArgs { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for StrategySlippageArgs { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for StrategySlippageArgs { + const NAME: &'static str = "StrategySlippageArgs"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "StrategySlippageArgs(uint256 amountOutMin)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) + .0 + .to_vec() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for StrategySlippageArgs { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.amountOutMin, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.amountOutMin, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. +```solidity +event TokenOutput(address tokenReceived, uint256 amountOut); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct TokenOutput { + #[allow(missing_docs)] + pub tokenReceived: alloy::sol_types::private::Address, + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for TokenOutput { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + tokenReceived: data.0, + amountOut: data.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.tokenReceived, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountOut), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 TokenOutput { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&TokenOutput> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(address _avBep20, address _pool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _avBep20: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _pool: alloy::sol_types::private::Address, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._avBep20, value._pool) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _avBep20: tuple.0, + _pool: 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> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._avBep20, + ), + ::tokenize( + &self._pool, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `avBep20()` and selector `0x25e2d625`. +```solidity +function avBep20() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct avBep20Call; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`avBep20()`](avBep20Call) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct avBep20Return { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: avBep20Call) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for avBep20Call { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: avBep20Return) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for avBep20Return { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for avBep20Call { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "avBep20()"; + const SELECTOR: [u8; 4] = [37u8, 226u8, 214u8, 37u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: avBep20Return = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: avBep20Return = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. +```solidity +function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub message: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ); + #[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, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.message) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + message: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageCall { + 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, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; + const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.message, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. +```solidity +function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub args: ::RustType, + } + ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Address, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.args) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + args: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageWithSlippageArgsReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageWithSlippageArgsReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; + const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.args, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `pool()` and selector `0x16f0115b`. +```solidity +function pool() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct poolCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`pool()`](poolCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct poolReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: poolCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for poolCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: poolReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for poolReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for poolCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "pool()"; + const SELECTOR: [u8; 4] = [22u8, 240u8, 17u8, 91u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: poolReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: poolReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`AvalonLendingStrategy`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum AvalonLendingStrategyCalls { + #[allow(missing_docs)] + avBep20(avBep20Call), + #[allow(missing_docs)] + handleGatewayMessage(handleGatewayMessageCall), + #[allow(missing_docs)] + handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), + #[allow(missing_docs)] + pool(poolCall), + } + #[automatically_derived] + impl AvalonLendingStrategyCalls { + /// 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, 240u8, 17u8, 91u8], + [37u8, 226u8, 214u8, 37u8], + [80u8, 99u8, 76u8, 14u8], + [127u8, 129u8, 79u8, 53u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for AvalonLendingStrategyCalls { + const NAME: &'static str = "AvalonLendingStrategyCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 4usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::avBep20(_) => ::SELECTOR, + Self::handleGatewayMessage(_) => { + ::SELECTOR + } + Self::handleGatewayMessageWithSlippageArgs(_) => { + ::SELECTOR + } + Self::pool(_) => ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn pool( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(AvalonLendingStrategyCalls::pool) + } + pool + }, + { + fn avBep20( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(AvalonLendingStrategyCalls::avBep20) + } + avBep20 + }, + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonLendingStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + AvalonLendingStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn pool( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonLendingStrategyCalls::pool) + } + pool + }, + { + fn avBep20( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonLendingStrategyCalls::avBep20) + } + avBep20 + }, + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonLendingStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + AvalonLendingStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::avBep20(inner) => { + ::abi_encoded_size(inner) + } + Self::handleGatewayMessage(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::pool(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::avBep20(inner) => { + ::abi_encode_raw(inner, out) + } + Self::handleGatewayMessage(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::pool(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + ///Container for all the [`AvalonLendingStrategy`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum AvalonLendingStrategyEvents { + #[allow(missing_docs)] + TokenOutput(TokenOutput), + } + #[automatically_derived] + impl AvalonLendingStrategyEvents { + /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for AvalonLendingStrategyEvents { + const NAME: &'static str = "AvalonLendingStrategyEvents"; + const COUNT: usize = 1usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::TokenOutput) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 AvalonLendingStrategyEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`AvalonLendingStrategy`](self) contract instance. + +See the [wrapper's documentation](`AvalonLendingStrategyInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> AvalonLendingStrategyInstance { + AvalonLendingStrategyInstance::::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: alloy_contract::private::Network, + >( + provider: P, + _avBep20: alloy::sol_types::private::Address, + _pool: alloy::sol_types::private::Address, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + AvalonLendingStrategyInstance::::deploy(provider, _avBep20, _pool) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + _avBep20: alloy::sol_types::private::Address, + _pool: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + AvalonLendingStrategyInstance::::deploy_builder(provider, _avBep20, _pool) + } + /**A [`AvalonLendingStrategy`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`AvalonLendingStrategy`](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 AvalonLendingStrategyInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for AvalonLendingStrategyInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("AvalonLendingStrategyInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > AvalonLendingStrategyInstance { + /**Creates a new wrapper around an on-chain [`AvalonLendingStrategy`](self) contract instance. + +See the [wrapper's documentation](`AvalonLendingStrategyInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + _avBep20: alloy::sol_types::private::Address, + _pool: alloy::sol_types::private::Address, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(provider, _avBep20, _pool); + 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, + _avBep20: alloy::sol_types::private::Address, + _pool: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { _avBep20, _pool }, + )[..], + ] + .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 AvalonLendingStrategyInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> AvalonLendingStrategyInstance { + AvalonLendingStrategyInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > AvalonLendingStrategyInstance { + /// 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( + &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 [`avBep20`] function. + pub fn avBep20(&self) -> alloy_contract::SolCallBuilder<&P, avBep20Call, N> { + self.call_builder(&avBep20Call) + } + ///Creates a new call builder for the [`handleGatewayMessage`] function. + pub fn handleGatewayMessage( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + message: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { + self.call_builder( + &handleGatewayMessageCall { + tokenSent, + amountIn, + recipient, + message, + }, + ) + } + ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. + pub fn handleGatewayMessageWithSlippageArgs( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + args: ::RustType, + ) -> alloy_contract::SolCallBuilder< + &P, + handleGatewayMessageWithSlippageArgsCall, + N, + > { + self.call_builder( + &handleGatewayMessageWithSlippageArgsCall { + tokenSent, + amountIn, + recipient, + args, + }, + ) + } + ///Creates a new call builder for the [`pool`] function. + pub fn pool(&self) -> alloy_contract::SolCallBuilder<&P, poolCall, N> { + self.call_builder(&poolCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > AvalonLendingStrategyInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`TokenOutput`] event. + pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/avalon_lst_strategy.rs b/crates/bindings/src/avalon_lst_strategy.rs new file mode 100644 index 000000000..31688a4bf --- /dev/null +++ b/crates/bindings/src/avalon_lst_strategy.rs @@ -0,0 +1,1812 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface AvalonLstStrategy { + struct StrategySlippageArgs { + uint256 amountOutMin; + } + + event TokenOutput(address tokenReceived, uint256 amountOut); + + constructor(address _solvLSTStrategy, address _avalonLendingStrategy); + + function avalonLendingStrategy() external view returns (address); + function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; + function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; + function solvLSTStrategy() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_solvLSTStrategy", + "type": "address", + "internalType": "contract SolvLSTStrategy" + }, + { + "name": "_avalonLendingStrategy", + "type": "address", + "internalType": "contract AvalonLendingStrategy" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "avalonLendingStrategy", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract AvalonLendingStrategy" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "handleGatewayMessage", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "message", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessageWithSlippageArgs", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "args", + "type": "tuple", + "internalType": "struct StrategySlippageArgs", + "components": [ + { + "name": "amountOutMin", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "solvLSTStrategy", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract SolvLSTStrategy" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "TokenOutput", + "inputs": [ + { + "name": "tokenReceived", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "amountOut", + "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 AvalonLstStrategy { + use super::*; + use alloy::sol_types as 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\r 8\x03\x80a\r \x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CJa\0\xD6_9_\x81\x81`S\x01R\x81\x81a\x03u\x01Ra\x03\xF5\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0CJ_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cF\"l1\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xF2#L\xF9\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\t\xD0V[a\0\xEDV[\0[a\0\xB1a\0\xC16`\x04a\n\x92V[a\x01\x17V[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[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 \x0F\x90\x04\x05\x04;C\xAF,\x7Fu,\xFE\x8C\xA7\xFF\xD73Q\x1A\x05>\x1A>\x8A\xD4\xB3\0\x13\x98\0$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\x80cF\"l1\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xF2#L\xF9\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\t\xD0V[a\0\xEDV[\0[a\0\xB1a\0\xC16`\x04a\n\x92V[a\x01\x17V[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[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 \x0F\x90\x04\x05\x04;C\xAF,\x7Fu,\xFE\x8C\xA7\xFF\xD73Q\x1A\x05>\x1A>\x8A\xD4\xB3\0\x13\x98\0$dsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct StrategySlippageArgs { uint256 amountOutMin; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct StrategySlippageArgs { + #[allow(missing_docs)] + pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: StrategySlippageArgs) -> Self { + (value.amountOutMin,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for StrategySlippageArgs { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { amountOutMin: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for StrategySlippageArgs { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for StrategySlippageArgs { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for StrategySlippageArgs { + const NAME: &'static str = "StrategySlippageArgs"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "StrategySlippageArgs(uint256 amountOutMin)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) + .0 + .to_vec() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for StrategySlippageArgs { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.amountOutMin, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.amountOutMin, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. +```solidity +event TokenOutput(address tokenReceived, uint256 amountOut); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct TokenOutput { + #[allow(missing_docs)] + pub tokenReceived: alloy::sol_types::private::Address, + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for TokenOutput { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + tokenReceived: data.0, + amountOut: data.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.tokenReceived, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountOut), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 TokenOutput { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&TokenOutput> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(address _solvLSTStrategy, address _avalonLendingStrategy); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _solvLSTStrategy: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _avalonLendingStrategy: alloy::sol_types::private::Address, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._solvLSTStrategy, value._avalonLendingStrategy) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _solvLSTStrategy: tuple.0, + _avalonLendingStrategy: 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> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._solvLSTStrategy, + ), + ::tokenize( + &self._avalonLendingStrategy, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `avalonLendingStrategy()` and selector `0x46226c31`. +```solidity +function avalonLendingStrategy() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct avalonLendingStrategyCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`avalonLendingStrategy()`](avalonLendingStrategyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct avalonLendingStrategyReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: avalonLendingStrategyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for avalonLendingStrategyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: avalonLendingStrategyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for avalonLendingStrategyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for avalonLendingStrategyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "avalonLendingStrategy()"; + const SELECTOR: [u8; 4] = [70u8, 34u8, 108u8, 49u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: avalonLendingStrategyReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: avalonLendingStrategyReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. +```solidity +function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub message: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ); + #[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, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.message) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + message: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageCall { + 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, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; + const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.message, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. +```solidity +function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub args: ::RustType, + } + ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Address, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.args) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + args: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageWithSlippageArgsReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageWithSlippageArgsReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; + const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.args, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `solvLSTStrategy()` and selector `0xf2234cf9`. +```solidity +function solvLSTStrategy() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct solvLSTStrategyCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`solvLSTStrategy()`](solvLSTStrategyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct solvLSTStrategyReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: solvLSTStrategyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for solvLSTStrategyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: solvLSTStrategyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for solvLSTStrategyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for solvLSTStrategyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "solvLSTStrategy()"; + const SELECTOR: [u8; 4] = [242u8, 35u8, 76u8, 249u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: solvLSTStrategyReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: solvLSTStrategyReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`AvalonLstStrategy`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum AvalonLstStrategyCalls { + #[allow(missing_docs)] + avalonLendingStrategy(avalonLendingStrategyCall), + #[allow(missing_docs)] + handleGatewayMessage(handleGatewayMessageCall), + #[allow(missing_docs)] + handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), + #[allow(missing_docs)] + solvLSTStrategy(solvLSTStrategyCall), + } + #[automatically_derived] + impl AvalonLstStrategyCalls { + /// 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]] = &[ + [70u8, 34u8, 108u8, 49u8], + [80u8, 99u8, 76u8, 14u8], + [127u8, 129u8, 79u8, 53u8], + [242u8, 35u8, 76u8, 249u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for AvalonLstStrategyCalls { + const NAME: &'static str = "AvalonLstStrategyCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 4usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::avalonLendingStrategy(_) => { + ::SELECTOR + } + Self::handleGatewayMessage(_) => { + ::SELECTOR + } + Self::handleGatewayMessageWithSlippageArgs(_) => { + ::SELECTOR + } + Self::solvLSTStrategy(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn avalonLendingStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonLstStrategyCalls::avalonLendingStrategy) + } + avalonLendingStrategy + }, + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonLstStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + AvalonLstStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + { + fn solvLSTStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonLstStrategyCalls::solvLSTStrategy) + } + solvLSTStrategy + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn avalonLendingStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonLstStrategyCalls::avalonLendingStrategy) + } + avalonLendingStrategy + }, + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonLstStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + AvalonLstStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + { + fn solvLSTStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonLstStrategyCalls::solvLSTStrategy) + } + solvLSTStrategy + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::avalonLendingStrategy(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::handleGatewayMessage(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::solvLSTStrategy(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::avalonLendingStrategy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::handleGatewayMessage(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::solvLSTStrategy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`AvalonLstStrategy`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum AvalonLstStrategyEvents { + #[allow(missing_docs)] + TokenOutput(TokenOutput), + } + #[automatically_derived] + impl AvalonLstStrategyEvents { + /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for AvalonLstStrategyEvents { + const NAME: &'static str = "AvalonLstStrategyEvents"; + const COUNT: usize = 1usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::TokenOutput) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 AvalonLstStrategyEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`AvalonLstStrategy`](self) contract instance. + +See the [wrapper's documentation](`AvalonLstStrategyInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> AvalonLstStrategyInstance { + AvalonLstStrategyInstance::::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: alloy_contract::private::Network, + >( + provider: P, + _solvLSTStrategy: alloy::sol_types::private::Address, + _avalonLendingStrategy: alloy::sol_types::private::Address, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + AvalonLstStrategyInstance::< + P, + N, + >::deploy(provider, _solvLSTStrategy, _avalonLendingStrategy) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + _solvLSTStrategy: alloy::sol_types::private::Address, + _avalonLendingStrategy: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + AvalonLstStrategyInstance::< + P, + N, + >::deploy_builder(provider, _solvLSTStrategy, _avalonLendingStrategy) + } + /**A [`AvalonLstStrategy`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`AvalonLstStrategy`](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 AvalonLstStrategyInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for AvalonLstStrategyInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("AvalonLstStrategyInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > AvalonLstStrategyInstance { + /**Creates a new wrapper around an on-chain [`AvalonLstStrategy`](self) contract instance. + +See the [wrapper's documentation](`AvalonLstStrategyInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + _solvLSTStrategy: alloy::sol_types::private::Address, + _avalonLendingStrategy: alloy::sol_types::private::Address, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder( + provider, + _solvLSTStrategy, + _avalonLendingStrategy, + ); + 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, + _solvLSTStrategy: alloy::sol_types::private::Address, + _avalonLendingStrategy: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + _solvLSTStrategy, + _avalonLendingStrategy, + }, + )[..], + ] + .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 AvalonLstStrategyInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> AvalonLstStrategyInstance { + AvalonLstStrategyInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > AvalonLstStrategyInstance { + /// 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( + &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 [`avalonLendingStrategy`] function. + pub fn avalonLendingStrategy( + &self, + ) -> alloy_contract::SolCallBuilder<&P, avalonLendingStrategyCall, N> { + self.call_builder(&avalonLendingStrategyCall) + } + ///Creates a new call builder for the [`handleGatewayMessage`] function. + pub fn handleGatewayMessage( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + message: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { + self.call_builder( + &handleGatewayMessageCall { + tokenSent, + amountIn, + recipient, + message, + }, + ) + } + ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. + pub fn handleGatewayMessageWithSlippageArgs( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + args: ::RustType, + ) -> alloy_contract::SolCallBuilder< + &P, + handleGatewayMessageWithSlippageArgsCall, + N, + > { + self.call_builder( + &handleGatewayMessageWithSlippageArgsCall { + tokenSent, + amountIn, + recipient, + args, + }, + ) + } + ///Creates a new call builder for the [`solvLSTStrategy`] function. + pub fn solvLSTStrategy( + &self, + ) -> alloy_contract::SolCallBuilder<&P, solvLSTStrategyCall, N> { + self.call_builder(&solvLSTStrategyCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > AvalonLstStrategyInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`TokenOutput`] event. + pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/avalon_tbtc_lending_strategy_forked.rs b/crates/bindings/src/avalon_tbtc_lending_strategy_forked.rs new file mode 100644 index 000000000..c06be1a12 --- /dev/null +++ b/crates/bindings/src/avalon_tbtc_lending_strategy_forked.rs @@ -0,0 +1,8013 @@ +///Module containing a contract's types and functions. +/** + +```solidity +library StdInvariant { + struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } + struct FuzzInterface { address addr; string[] artifacts; } + struct FuzzSelector { address addr; bytes4[] selectors; } +} +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod StdInvariant { + use super::*; + use alloy::sol_types as alloy_sol_types; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzArtifactSelector { + #[allow(missing_docs)] + pub artifact: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub selectors: alloy::sol_types::private::Vec< + 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 as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::String, + alloy::sol_types::private::Vec>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzArtifactSelector) -> Self { + (value.artifact, value.selectors) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzArtifactSelector { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + artifact: tuple.0, + selectors: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzArtifactSelector { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.artifact, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.selectors), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzArtifactSelector { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzArtifactSelector { + const NAME: &'static str = "FuzzArtifactSelector"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzArtifactSelector(string artifact,bytes4[] selectors)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.artifact, + ) + .0, + , + > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzArtifactSelector { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.artifact, + ) + + , + > as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.selectors, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.artifact, + out, + ); + , + > as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.selectors, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzInterface { address addr; string[] artifacts; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzInterface { + #[allow(missing_docs)] + pub addr: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub artifacts: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzInterface) -> Self { + (value.addr, value.artifacts) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzInterface { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + addr: tuple.0, + artifacts: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzInterface { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzInterface { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.addr, + ), + as alloy_sol_types::SolType>::tokenize(&self.artifacts), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzInterface { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzInterface { + const NAME: &'static str = "FuzzInterface"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzInterface(address addr,string[] artifacts)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.addr, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzInterface { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.addr, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.artifacts, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.addr, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.artifacts, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzSelector { address addr; bytes4[] selectors; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzSelector { + #[allow(missing_docs)] + pub addr: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub selectors: alloy::sol_types::private::Vec< + 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 as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Vec>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzSelector) -> Self { + (value.addr, value.selectors) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzSelector { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + addr: tuple.0, + selectors: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzSelector { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzSelector { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.addr, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.selectors), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzSelector { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzSelector { + const NAME: &'static str = "FuzzSelector"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzSelector(address addr,bytes4[] selectors)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.addr, + ) + .0, + , + > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzSelector { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.addr, + ) + + , + > as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.selectors, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.addr, + out, + ); + , + > as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.selectors, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. + +See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> StdInvariantInstance { + StdInvariantInstance::::new(address, provider) + } + /**A [`StdInvariant`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`StdInvariant`](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 StdInvariantInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for StdInvariantInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("StdInvariantInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. + +See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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 StdInvariantInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> StdInvariantInstance { + StdInvariantInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} +/** + +Generated by the following Solidity interface... +```solidity +library StdInvariant { + struct FuzzArtifactSelector { + string artifact; + bytes4[] selectors; + } + struct FuzzInterface { + address addr; + string[] artifacts; + } + struct FuzzSelector { + address addr; + bytes4[] selectors; + } +} + +interface AvalonTBTCLendingStrategyForked { + event log(string); + event log_address(address); + event log_array(uint256[] val); + event log_array(int256[] val); + event log_array(address[] val); + event log_bytes(bytes); + event log_bytes32(bytes32); + event log_int(int256); + event log_named_address(string key, address val); + event log_named_array(string key, uint256[] val); + event log_named_array(string key, int256[] val); + event log_named_array(string key, address[] val); + event log_named_bytes(string key, bytes val); + event log_named_bytes32(string key, bytes32 val); + event log_named_decimal_int(string key, int256 val, uint256 decimals); + event log_named_decimal_uint(string key, uint256 val, uint256 decimals); + event log_named_int(string key, int256 val); + event log_named_string(string key, string val); + event log_named_uint(string key, uint256 val); + event log_string(string); + event log_uint(uint256); + event logs(bytes); + + function IS_TEST() external view returns (bool); + function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); + function excludeContracts() external view returns (address[] memory excludedContracts_); + function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); + function excludeSenders() external view returns (address[] memory excludedSenders_); + function failed() external view returns (bool); + function setUp() external; + function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; + function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); + function targetArtifacts() external view returns (string[] memory targetedArtifacts_); + function targetContracts() external view returns (address[] memory targetedContracts_); + function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); + function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); + function targetSenders() external view returns (address[] memory targetedSenders_); + function testAvalonTBTCStrategy() external; + function token() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "IS_TEST", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeArtifacts", + "inputs": [], + "outputs": [ + { + "name": "excludedArtifacts_", + "type": "string[]", + "internalType": "string[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeContracts", + "inputs": [], + "outputs": [ + { + "name": "excludedContracts_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeSelectors", + "inputs": [], + "outputs": [ + { + "name": "excludedSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzSelector[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeSenders", + "inputs": [], + "outputs": [ + { + "name": "excludedSenders_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "failed", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "setUp", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "simulateForkAndTransfer", + "inputs": [ + { + "name": "forkAtBlock", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "sender", + "type": "address", + "internalType": "address" + }, + { + "name": "receiver", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "targetArtifactSelectors", + "inputs": [], + "outputs": [ + { + "name": "targetedArtifactSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzArtifactSelector[]", + "components": [ + { + "name": "artifact", + "type": "string", + "internalType": "string" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetArtifacts", + "inputs": [], + "outputs": [ + { + "name": "targetedArtifacts_", + "type": "string[]", + "internalType": "string[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetContracts", + "inputs": [], + "outputs": [ + { + "name": "targetedContracts_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetInterfaces", + "inputs": [], + "outputs": [ + { + "name": "targetedInterfaces_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzInterface[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "artifacts", + "type": "string[]", + "internalType": "string[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetSelectors", + "inputs": [], + "outputs": [ + { + "name": "targetedSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzSelector[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetSenders", + "inputs": [], + "outputs": [ + { + "name": "targetedSenders_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "testAvalonTBTCStrategy", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "token", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IERC20" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "log", + "inputs": [ + { + "name": "", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_address", + "inputs": [ + { + "name": "", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "uint256[]", + "indexed": false, + "internalType": "uint256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "int256[]", + "indexed": false, + "internalType": "int256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "address[]", + "indexed": false, + "internalType": "address[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_bytes", + "inputs": [ + { + "name": "", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_bytes32", + "inputs": [ + { + "name": "", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_int", + "inputs": [ + { + "name": "", + "type": "int256", + "indexed": false, + "internalType": "int256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_address", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256[]", + "indexed": false, + "internalType": "uint256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256[]", + "indexed": false, + "internalType": "int256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "address[]", + "indexed": false, + "internalType": "address[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_bytes", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_bytes32", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_decimal_int", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256", + "indexed": false, + "internalType": "int256" + }, + { + "name": "decimals", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_decimal_uint", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "decimals", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_int", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256", + "indexed": false, + "internalType": "int256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_string", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_uint", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_string", + "inputs": [ + { + "name": "", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_uint", + "inputs": [ + { + "name": "", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "logs", + "inputs": [ + { + "name": "", + "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 AvalonTBTCLendingStrategyForked { + use super::*; + use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15`+W__\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16t\xBB\xA2\xEF\x94]R^<#\x14a\x01=_\xFD[P`@Q\x7F\xCAf\x9F\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\x81Rs\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05\x94W__\xFD[PZ\xF1\x15\x80\x15a\x05\xA6W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x06 W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06D\x91\x90a\x17\x8CV[Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x06\x91W__\xFD[PZ\xF1\x15\x80\x15a\x06\xA3W=__>=_\xFD[PP`@Q\x7F\xCAf\x9F\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\x81Rs\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x92Pc\xCAf\x9F\xA7\x91P`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07\x1DW__\xFD[PZ\xF1\x15\x80\x15a\x07/W=__>=_\xFD[PP`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x84\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x84\x16\x92Pc\x7F\x81O5\x91P`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07\xBDW__\xFD[PZ\xF1\x15\x80\x15a\x07\xCFW=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\x1FW__\xFD[PZ\xF1\x15\x80\x15a\x081W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\x08\xC7\x93Pa\x01\0\x90\x91\x04`\x01`\x01`\xA0\x1B\x03\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x9DW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\xC1\x91\x90a\x17\xB2V[_a\x13GV[`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t*W__\xFD[PZ\xF1\x15\x80\x15a\t=_\xFD[PP`\x1FT`@Q\x7Fi2\x8D\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\x81Ra\x01\0\x90\x91\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01R`\x01`D\x83\x01R\x85\x16\x92Pci2\x8D\xEC\x91P`d\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\t\xBCW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\xE0\x91\x90a\x17\xB2V[Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\n-W__\xFD[PZ\xF1\x15\x80\x15a\n?W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\n\xDD\x93Pa\x01\0\x90\x91\x04`\x01`\x01`\xA0\x1B\x03\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\n\xABW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xCF\x91\x90a\x17\xB2V[g\r\xE0\xB6\xB3\xA7d\0\0a\x13GV[PPPV[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x03\xE7W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x0B5\x90a\x17;V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0Ba\x90a\x17;V[\x80\x15a\x0B\xACW\x80`\x1F\x10a\x0B\x83Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\xACV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\x8FW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x0CCW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0B\xF0W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0B\x05V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x03\xE7W\x83\x82\x90_R` _ \x01\x80Ta\x0C\x9B\x90a\x17;V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C\xC7\x90a\x17;V[\x80\x15a\r\x12W\x80`\x1F\x10a\x0C\xE9Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\r\x12V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0C\xF5W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0C~V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x03\xE7W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0E\x04W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\xB1W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\rIV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x03\xE7W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0E\xFAW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0E\xA7W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0E?V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x03\xE7W\x83\x82\x90_R` _ \x01\x80Ta\x0FR\x90a\x17;V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F~\x90a\x17;V[\x80\x15a\x0F\xC9W\x80`\x1F\x10a\x0F\xA0Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F\xC9V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\xACW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0F5V[`\x08T_\x90`\xFF\x16\x15a\x0F\xF4WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\x82W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\xA6\x91\x90a\x17\xB2V[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xAAW` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\x8CWPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\xA6W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x11\xCD\x91\x90\x81\x01\x90a\x17\xF6V[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x11\xEB\x92\x91\x90a\x18\xAAV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x12\x07W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12+\x91\x90a\x17\xB2V[P`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12\x97W__\xFD[PZ\xF1\x15\x80\x15a\x12\xA9W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x13\x1CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13@\x91\x90a\x17\x8CV[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x13\xB0W__\xFD[PZ\xFA\x15\x80\x15a\x13\xC2W=__>=_\xFD[PPPPPPV[a\r\x1E\x80a\x18\xCC\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x14\x17W\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x13\xF0V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15+W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`\x01`\x01`\xA0\x1B\x03\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x15\x11W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x14\xFB\x84\x86Qa\x14\"V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x14\xC1V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x14vV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x15\x89W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x15IV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15+W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x15\xDF`@\x88\x01\x82a\x14\"V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x15\xFA\x81\x83a\x157V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\xB9V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15+W`?\x19\x87\x86\x03\x01\x84Ra\x16S\x85\x83Qa\x14\"V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x167V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15+W`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x16\xC9`@\x87\x01\x82a\x157V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16\x8EV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x16\xF5W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x17\rW__\xFD[\x845\x93Pa\x17\x1D` \x86\x01a\x16\xDFV[\x92Pa\x17+`@\x86\x01a\x16\xDFV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x17OW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x17\x86W\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17\x9CW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x17\xABW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x17\xC2W__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x18\x06W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\x1CW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x18,W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18FWa\x18Fa\x17\xC9V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x18vWa\x18va\x17\xC9V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x18\x8DW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x18\xBC`@\x83\x01\x85a\x14\"V[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\x1E8\x03\x80a\r\x1E\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CHa\0\xD6_9_\x81\x81`S\x01R\x81\x81a\x01U\x01Ra\x02\x89\x01R_\x81\x81`\xA3\x01R\x81\x81a\x01\xC1\x01R\x81\x81a\x03(\x01Ra\x04b\x01Ra\x0CH_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x16\xF0\x11[\x14a\0NW\x80c%\xE2\xD6%\x14a\0\x9EW\x80cPcL\x0E\x14a\0\xC5W\x80c\x7F\x81O5\x14a\0\xDAW[__\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\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[a\0\xD8a\0\xD36`\x04a\t\xCEV[a\0\xEDV[\0[a\0\xD8a\0\xE86`\x04a\n\x90V[a\x01\x17V[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x14V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xBFV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x83V[`@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\x83\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B8V[`@Q\x7Fa{\xA07\0\0\0\0\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`$\x82\x01\x87\x90R\x85\x81\x16`D\x83\x01R_`d\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\x90ca{\xA07\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\xCCW__\xFD[PZ\xF1\x15\x80\x15a\x02\xDEW=__>=_\xFD[PP`@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\x86\x81\x16`\x04\x83\x01R_\x93P\x7F\0\0\0\0\0\0\0\0\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\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03nW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x92\x91\x90a\x0B8V[\x90P\x81\x81\x11a\x03\xE8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x03\xF3\x83\x83a\x0B|V[\x84Q\x90\x91P\x81\x10\x15a\x04GW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xDFV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05}\x90\x85\x90\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\x90`\x84\x01[`@\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~V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1B\x91\x90a\x0B8V[a\x06%\x91\x90a\x0B\x95V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05}\x90\x85\x90\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\x90`d\x01a\x05\x19V[_a\x06\xDF\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\x07t\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07oW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFD\x91\x90a\x0B\xA8V[a\x07oW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[PPPV[``a\x07\x82\x84\x84_\x85a\x07\x8CV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\x04W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08hW`@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\x03\xDFV[__\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\x08\x90\x91\x90a\x0B\xC7V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xCAW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xCFV[``\x91P[P\x91P\x91Pa\x08\xDF\x82\x82\x86a\x08\xEAV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xF9WP\x81a\x07\x85V[\x82Q\x15a\t\tW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xDF\x91\x90a\x0B\xDDV[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\tDW__\xFD[PV[\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\x97Wa\t\x97a\tGV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC6Wa\t\xC6a\tGV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE1W__\xFD[\x845a\t\xEC\x81a\t#V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x03\x81a\t#V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x1EW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n.W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nHWa\nHa\tGV[a\n[` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9DV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\noW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA4W__\xFD[\x855a\n\xAF\x81a\t#V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC6\x81a\t#V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF7W__\xFD[Pa\x0B\0a\ttV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B%W__\xFD[Pa\x0B.a\ttV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BHW__\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[\x81\x81\x03\x81\x81\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[_` \x82\x84\x03\x12\x15a\x0B\xB8W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x85W__\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\xFE\xA2dipfsX\"\x12 \x82\xCFY\x81d\x94k\x8Fq\x9CM\x82\xEF^\xF6\x0E=\xDAW\xBE\xC7=\xE3\xE8\x87\xB6ny\x0B\xF7WqdsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 \xF4\xB6\x19\xDF\x9C\x12\xD9R'\xE4\xE7\xE3\xA8\x86\x8C\xF2k\x86E\xA0\xD5\xD8\xB2V\xEEc\xB7\x9DVu\x1A6dsolcC\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\0\xFBW_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\x93W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x01\xBBW\x80c\xF9\xCE\x0EZ\x14a\x01\xC3W\x80c\xFAv&\xD4\x14a\x01\xD6W\x80c\xFC\x0CTj\x14a\x01\xE3W__\xFD[\x80c\x91j\x17\xC6\x14a\x01~W\x80c\xB0FO\xDC\x14a\x01\x93W\x80c\xB5P\x8A\xA9\x14a\x01\x9BW\x80c\xBAAO\xA6\x14a\x01\xA3W__\xFD[\x80c?r\x86\xF4\x11a\0\xCEW\x80c?r\x86\xF4\x14a\x01DW\x80cIi\xBB\x03\x14a\x01LW\x80cf\xD9\xA9\xA0\x14a\x01TW\x80c\x85\"l\x81\x14a\x01iW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x1E\xD7\x83\x1C\x14a\x01\tW\x80c*\xDE8\x80\x14a\x01'W\x80c>^<#\x14a\x01=_\xFD[P`@Q\x7F\xCAf\x9F\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\x81Rs\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05\x94W__\xFD[PZ\xF1\x15\x80\x15a\x05\xA6W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x06 W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06D\x91\x90a\x17\x8CV[Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x06\x91W__\xFD[PZ\xF1\x15\x80\x15a\x06\xA3W=__>=_\xFD[PP`@Q\x7F\xCAf\x9F\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\x81Rs\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x92Pc\xCAf\x9F\xA7\x91P`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07\x1DW__\xFD[PZ\xF1\x15\x80\x15a\x07/W=__>=_\xFD[PP`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x84\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x84\x16\x92Pc\x7F\x81O5\x91P`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07\xBDW__\xFD[PZ\xF1\x15\x80\x15a\x07\xCFW=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\x1FW__\xFD[PZ\xF1\x15\x80\x15a\x081W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\x08\xC7\x93Pa\x01\0\x90\x91\x04`\x01`\x01`\xA0\x1B\x03\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x9DW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\xC1\x91\x90a\x17\xB2V[_a\x13GV[`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t*W__\xFD[PZ\xF1\x15\x80\x15a\t=_\xFD[PP`\x1FT`@Q\x7Fi2\x8D\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\x81Ra\x01\0\x90\x91\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01R`\x01`D\x83\x01R\x85\x16\x92Pci2\x8D\xEC\x91P`d\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\t\xBCW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\xE0\x91\x90a\x17\xB2V[Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\n-W__\xFD[PZ\xF1\x15\x80\x15a\n?W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\n\xDD\x93Pa\x01\0\x90\x91\x04`\x01`\x01`\xA0\x1B\x03\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\n\xABW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xCF\x91\x90a\x17\xB2V[g\r\xE0\xB6\xB3\xA7d\0\0a\x13GV[PPPV[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x03\xE7W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x0B5\x90a\x17;V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0Ba\x90a\x17;V[\x80\x15a\x0B\xACW\x80`\x1F\x10a\x0B\x83Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\xACV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\x8FW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x0CCW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0B\xF0W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0B\x05V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x03\xE7W\x83\x82\x90_R` _ \x01\x80Ta\x0C\x9B\x90a\x17;V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C\xC7\x90a\x17;V[\x80\x15a\r\x12W\x80`\x1F\x10a\x0C\xE9Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\r\x12V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0C\xF5W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0C~V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x03\xE7W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0E\x04W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\xB1W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\rIV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x03\xE7W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0E\xFAW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0E\xA7W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0E?V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x03\xE7W\x83\x82\x90_R` _ \x01\x80Ta\x0FR\x90a\x17;V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F~\x90a\x17;V[\x80\x15a\x0F\xC9W\x80`\x1F\x10a\x0F\xA0Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F\xC9V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\xACW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0F5V[`\x08T_\x90`\xFF\x16\x15a\x0F\xF4WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\x82W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\xA6\x91\x90a\x17\xB2V[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xAAW` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\x8CWPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\xA6W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x11\xCD\x91\x90\x81\x01\x90a\x17\xF6V[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x11\xEB\x92\x91\x90a\x18\xAAV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x12\x07W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12+\x91\x90a\x17\xB2V[P`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12\x97W__\xFD[PZ\xF1\x15\x80\x15a\x12\xA9W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x13\x1CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13@\x91\x90a\x17\x8CV[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x13\xB0W__\xFD[PZ\xFA\x15\x80\x15a\x13\xC2W=__>=_\xFD[PPPPPPV[a\r\x1E\x80a\x18\xCC\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x14\x17W\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x13\xF0V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15+W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`\x01`\x01`\xA0\x1B\x03\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x15\x11W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x14\xFB\x84\x86Qa\x14\"V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x14\xC1V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x14vV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x15\x89W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x15IV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15+W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x15\xDF`@\x88\x01\x82a\x14\"V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x15\xFA\x81\x83a\x157V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\xB9V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15+W`?\x19\x87\x86\x03\x01\x84Ra\x16S\x85\x83Qa\x14\"V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x167V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15+W`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x16\xC9`@\x87\x01\x82a\x157V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16\x8EV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x16\xF5W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x17\rW__\xFD[\x845\x93Pa\x17\x1D` \x86\x01a\x16\xDFV[\x92Pa\x17+`@\x86\x01a\x16\xDFV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x17OW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x17\x86W\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17\x9CW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x17\xABW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x17\xC2W__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x18\x06W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\x1CW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x18,W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18FWa\x18Fa\x17\xC9V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x18vWa\x18va\x17\xC9V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x18\x8DW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x18\xBC`@\x83\x01\x85a\x14\"V[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\x1E8\x03\x80a\r\x1E\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CHa\0\xD6_9_\x81\x81`S\x01R\x81\x81a\x01U\x01Ra\x02\x89\x01R_\x81\x81`\xA3\x01R\x81\x81a\x01\xC1\x01R\x81\x81a\x03(\x01Ra\x04b\x01Ra\x0CH_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x16\xF0\x11[\x14a\0NW\x80c%\xE2\xD6%\x14a\0\x9EW\x80cPcL\x0E\x14a\0\xC5W\x80c\x7F\x81O5\x14a\0\xDAW[__\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\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[a\0\xD8a\0\xD36`\x04a\t\xCEV[a\0\xEDV[\0[a\0\xD8a\0\xE86`\x04a\n\x90V[a\x01\x17V[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x14V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xBFV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x83V[`@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\x83\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B8V[`@Q\x7Fa{\xA07\0\0\0\0\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`$\x82\x01\x87\x90R\x85\x81\x16`D\x83\x01R_`d\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\x90ca{\xA07\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\xCCW__\xFD[PZ\xF1\x15\x80\x15a\x02\xDEW=__>=_\xFD[PP`@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\x86\x81\x16`\x04\x83\x01R_\x93P\x7F\0\0\0\0\0\0\0\0\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\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03nW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x92\x91\x90a\x0B8V[\x90P\x81\x81\x11a\x03\xE8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x03\xF3\x83\x83a\x0B|V[\x84Q\x90\x91P\x81\x10\x15a\x04GW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xDFV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05}\x90\x85\x90\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\x90`\x84\x01[`@\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~V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1B\x91\x90a\x0B8V[a\x06%\x91\x90a\x0B\x95V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05}\x90\x85\x90\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\x90`d\x01a\x05\x19V[_a\x06\xDF\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\x07t\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07oW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFD\x91\x90a\x0B\xA8V[a\x07oW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[PPPV[``a\x07\x82\x84\x84_\x85a\x07\x8CV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\x04W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08hW`@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\x03\xDFV[__\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\x08\x90\x91\x90a\x0B\xC7V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xCAW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xCFV[``\x91P[P\x91P\x91Pa\x08\xDF\x82\x82\x86a\x08\xEAV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xF9WP\x81a\x07\x85V[\x82Q\x15a\t\tW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xDF\x91\x90a\x0B\xDDV[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\tDW__\xFD[PV[\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\x97Wa\t\x97a\tGV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC6Wa\t\xC6a\tGV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE1W__\xFD[\x845a\t\xEC\x81a\t#V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x03\x81a\t#V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x1EW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n.W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nHWa\nHa\tGV[a\n[` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9DV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\noW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA4W__\xFD[\x855a\n\xAF\x81a\t#V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC6\x81a\t#V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF7W__\xFD[Pa\x0B\0a\ttV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B%W__\xFD[Pa\x0B.a\ttV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BHW__\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[\x81\x81\x03\x81\x81\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[_` \x82\x84\x03\x12\x15a\x0B\xB8W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x85W__\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\xFE\xA2dipfsX\"\x12 \x82\xCFY\x81d\x94k\x8Fq\x9CM\x82\xEF^\xF6\x0E=\xDAW\xBE\xC7=\xE3\xE8\x87\xB6ny\x0B\xF7WqdsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 \xF4\xB6\x19\xDF\x9C\x12\xD9R'\xE4\xE7\xE3\xA8\x86\x8C\xF2k\x86E\xA0\xD5\xD8\xB2V\xEEc\xB7\x9DVu\x1A6dsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. +```solidity +event log(string); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log { + type DataTuple<'a> = (alloy::sol_types::sol_data::String,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log(string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, + 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, + 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. +```solidity +event log_address(address); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_address { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_address { + type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_address(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, + 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, + 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_address { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_address> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_address) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. +```solidity +event log_array(uint256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_0 { + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_0 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(uint256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, + 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, + 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_0 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_0> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. +```solidity +event log_array(int256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_1 { + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_1 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(int256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, + 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, + 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_1 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_1> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. +```solidity +event log_array(address[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_2 { + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_2 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(address[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, + 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, + 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_2 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_2> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. +```solidity +event log_bytes(bytes); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_bytes { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_bytes { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_bytes(bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, + 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, + 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_bytes { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_bytes> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. +```solidity +event log_bytes32(bytes32); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_bytes32 { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_bytes32 { + type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_bytes32(bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, + 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, + 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_bytes32 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_bytes32> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. +```solidity +event log_int(int256); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_int { + #[allow(missing_docs)] + pub _0: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_int { + type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_int(int256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, + 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, + 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. +```solidity +event log_named_address(string key, address val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_address { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_address { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Address, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_address(string,address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, + 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, + 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_address { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_address> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. +```solidity +event log_named_array(string key, uint256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_0 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_0 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, + 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, + 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_0 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_0> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. +```solidity +event log_named_array(string key, int256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_1 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_1 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,int256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, + 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, + 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_1 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_1> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. +```solidity +event log_named_array(string key, address[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_2 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_2 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,address[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, + 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, + 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_2 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_2> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. +```solidity +event log_named_bytes(string key, bytes val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_bytes { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_bytes { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Bytes, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, + 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, + 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_bytes { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_bytes> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. +```solidity +event log_named_bytes32(string key, bytes32 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_bytes32 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_bytes32 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::FixedBytes<32>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, + 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, + 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_bytes32 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. +```solidity +event log_named_decimal_int(string key, int256 val, uint256 decimals); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_decimal_int { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::I256, + #[allow(missing_docs)] + pub decimals: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_decimal_int { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Int<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, + 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, + 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + key: data.0, + val: data.1, + decimals: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + as alloy_sol_types::SolType>::tokenize(&self.decimals), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_decimal_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. +```solidity +event log_named_decimal_uint(string key, uint256 val, uint256 decimals); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_decimal_uint { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub decimals: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_decimal_uint { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, + 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, + 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + key: data.0, + val: data.1, + decimals: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + as alloy_sol_types::SolType>::tokenize(&self.decimals), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. +```solidity +event log_named_int(string key, int256 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_int { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_int { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Int<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_int(string,int256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, + 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, + 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. +```solidity +event log_named_string(string key, string val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_string { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::String, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_string { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::String, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_string(string,string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, + 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, + 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_string { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_string> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. +```solidity +event log_named_uint(string key, uint256 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_uint { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_uint { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, + 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, + 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. +```solidity +event log_string(string); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_string { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_string { + type DataTuple<'a> = (alloy::sol_types::sol_data::String,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_string(string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, + 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, + 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_string { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_string> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_string) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. +```solidity +event log_uint(uint256); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_uint { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_uint { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_uint(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, + 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, + 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. +```solidity +event logs(bytes); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct logs { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for logs { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "logs(bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, + 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, + 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 logs { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&logs> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &logs) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. +```solidity +function IS_TEST() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IS_TESTCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IS_TESTReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IS_TESTCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IS_TESTCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IS_TESTReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IS_TESTReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for IS_TESTCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "IS_TEST()"; + const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: IS_TESTReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: IS_TESTReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. +```solidity +function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeArtifactsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeArtifactsReturn { + #[allow(missing_docs)] + pub excludedArtifacts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeArtifactsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeArtifactsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeArtifactsReturn) -> Self { + (value.excludedArtifacts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeArtifactsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedArtifacts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeArtifactsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeArtifacts()"; + const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeArtifactsReturn = r.into(); + r.excludedArtifacts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeArtifactsReturn = r.into(); + r.excludedArtifacts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. +```solidity +function excludeContracts() external view returns (address[] memory excludedContracts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeContractsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeContractsReturn { + #[allow(missing_docs)] + pub excludedContracts_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeContractsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeContractsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeContractsReturn) -> Self { + (value.excludedContracts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeContractsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedContracts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeContractsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeContracts()"; + const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeContractsReturn = r.into(); + r.excludedContracts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeContractsReturn = r.into(); + r.excludedContracts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. +```solidity +function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSelectorsReturn { + #[allow(missing_docs)] + pub excludedSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSelectorsReturn) -> Self { + (value.excludedSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeSelectors()"; + const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeSelectorsReturn = r.into(); + r.excludedSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeSelectorsReturn = r.into(); + r.excludedSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. +```solidity +function excludeSenders() external view returns (address[] memory excludedSenders_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSendersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSendersReturn { + #[allow(missing_docs)] + pub excludedSenders_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: excludeSendersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for excludeSendersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSendersReturn) -> Self { + (value.excludedSenders_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSendersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { excludedSenders_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeSendersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeSenders()"; + const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeSendersReturn = r.into(); + r.excludedSenders_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeSendersReturn = r.into(); + r.excludedSenders_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `failed()` and selector `0xba414fa6`. +```solidity +function failed() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct failedCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`failed()`](failedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct failedReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: failedCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for failedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: failedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for failedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for failedCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "failed()"; + const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: failedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: failedReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `setUp()` and selector `0x0a9254e4`. +```solidity +function setUp() external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setUpCall; + ///Container type for the return parameters of the [`setUp()`](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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setUpCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setUpReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setUpReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setUpCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setUpReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setUp()"; + const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setUpReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. +```solidity +function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct simulateForkAndTransferCall { + #[allow(missing_docs)] + pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub sender: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct simulateForkAndTransferReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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::Uint<256>, + ); + #[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::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferCall) -> Self { + (value.forkAtBlock, value.sender, value.receiver, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for simulateForkAndTransferCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + forkAtBlock: tuple.0, + sender: tuple.1, + receiver: tuple.2, + amount: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for simulateForkAndTransferReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl simulateForkAndTransferReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for simulateForkAndTransferCall { + type Parameters<'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::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = simulateForkAndTransferReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; + const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), + ::tokenize( + &self.sender, + ), + ::tokenize( + &self.receiver, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + simulateForkAndTransferReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. +```solidity +function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactSelectorsReturn { + #[allow(missing_docs)] + pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactSelectorsReturn) -> Self { + (value.targetedArtifactSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedArtifactSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetArtifactSelectors()"; + const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetArtifacts()` and selector `0x85226c81`. +```solidity +function targetArtifacts() external view returns (string[] memory targetedArtifacts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactsReturn { + #[allow(missing_docs)] + pub targetedArtifacts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetArtifactsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsReturn) -> Self { + (value.targetedArtifacts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedArtifacts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetArtifactsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetArtifacts()"; + const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetContracts()` and selector `0x3f7286f4`. +```solidity +function targetContracts() external view returns (address[] memory targetedContracts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetContractsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetContractsReturn { + #[allow(missing_docs)] + pub targetedContracts_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetContractsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetContractsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetContractsReturn) -> Self { + (value.targetedContracts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetContractsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedContracts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetContractsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetContracts()"; + const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetContractsReturn = r.into(); + r.targetedContracts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetContractsReturn = r.into(); + r.targetedContracts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. +```solidity +function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetInterfacesCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetInterfacesReturn { + #[allow(missing_docs)] + pub targetedInterfaces_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetInterfacesCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetInterfacesCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetInterfacesReturn) -> Self { + (value.targetedInterfaces_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetInterfacesReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedInterfaces_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetInterfacesCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetInterfaces()"; + const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetSelectors()` and selector `0x916a17c6`. +```solidity +function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSelectorsReturn { + #[allow(missing_docs)] + pub targetedSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetSelectorsReturn) -> Self { + (value.targetedSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetSelectors()"; + const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. +```solidity +function targetSenders() external view returns (address[] memory targetedSenders_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSendersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSendersReturn { + #[allow(missing_docs)] + pub targetedSenders_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSendersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersReturn) -> Self { + (value.targetedSenders_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSendersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { targetedSenders_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetSendersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetSenders()"; + const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetSendersReturn = r.into(); + r.targetedSenders_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetSendersReturn = r.into(); + r.targetedSenders_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `testAvalonTBTCStrategy()` and selector `0x4969bb03`. +```solidity +function testAvalonTBTCStrategy() external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct testAvalonTBTCStrategyCall; + ///Container type for the return parameters of the [`testAvalonTBTCStrategy()`](testAvalonTBTCStrategyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct testAvalonTBTCStrategyReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: testAvalonTBTCStrategyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for testAvalonTBTCStrategyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: testAvalonTBTCStrategyReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for testAvalonTBTCStrategyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl testAvalonTBTCStrategyReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for testAvalonTBTCStrategyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = testAvalonTBTCStrategyReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "testAvalonTBTCStrategy()"; + const SELECTOR: [u8; 4] = [73u8, 105u8, 187u8, 3u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + testAvalonTBTCStrategyReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `token()` and selector `0xfc0c546a`. +```solidity +function token() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct tokenCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`token()`](tokenCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct tokenReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for tokenCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for tokenReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for tokenCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "token()"; + const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`AvalonTBTCLendingStrategyForked`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum AvalonTBTCLendingStrategyForkedCalls { + #[allow(missing_docs)] + IS_TEST(IS_TESTCall), + #[allow(missing_docs)] + excludeArtifacts(excludeArtifactsCall), + #[allow(missing_docs)] + excludeContracts(excludeContractsCall), + #[allow(missing_docs)] + excludeSelectors(excludeSelectorsCall), + #[allow(missing_docs)] + excludeSenders(excludeSendersCall), + #[allow(missing_docs)] + failed(failedCall), + #[allow(missing_docs)] + setUp(setUpCall), + #[allow(missing_docs)] + simulateForkAndTransfer(simulateForkAndTransferCall), + #[allow(missing_docs)] + targetArtifactSelectors(targetArtifactSelectorsCall), + #[allow(missing_docs)] + targetArtifacts(targetArtifactsCall), + #[allow(missing_docs)] + targetContracts(targetContractsCall), + #[allow(missing_docs)] + targetInterfaces(targetInterfacesCall), + #[allow(missing_docs)] + targetSelectors(targetSelectorsCall), + #[allow(missing_docs)] + targetSenders(targetSendersCall), + #[allow(missing_docs)] + testAvalonTBTCStrategy(testAvalonTBTCStrategyCall), + #[allow(missing_docs)] + token(tokenCall), + } + #[automatically_derived] + impl AvalonTBTCLendingStrategyForkedCalls { + /// 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]] = &[ + [10u8, 146u8, 84u8, 228u8], + [30u8, 215u8, 131u8, 28u8], + [42u8, 222u8, 56u8, 128u8], + [62u8, 94u8, 60u8, 35u8], + [63u8, 114u8, 134u8, 244u8], + [73u8, 105u8, 187u8, 3u8], + [102u8, 217u8, 169u8, 160u8], + [133u8, 34u8, 108u8, 129u8], + [145u8, 106u8, 23u8, 198u8], + [176u8, 70u8, 79u8, 220u8], + [181u8, 80u8, 138u8, 169u8], + [186u8, 65u8, 79u8, 166u8], + [226u8, 12u8, 159u8, 113u8], + [249u8, 206u8, 14u8, 90u8], + [250u8, 118u8, 38u8, 212u8], + [252u8, 12u8, 84u8, 106u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for AvalonTBTCLendingStrategyForkedCalls { + const NAME: &'static str = "AvalonTBTCLendingStrategyForkedCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 16usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::IS_TEST(_) => ::SELECTOR, + Self::excludeArtifacts(_) => { + ::SELECTOR + } + Self::excludeContracts(_) => { + ::SELECTOR + } + Self::excludeSelectors(_) => { + ::SELECTOR + } + Self::excludeSenders(_) => { + ::SELECTOR + } + Self::failed(_) => ::SELECTOR, + Self::setUp(_) => ::SELECTOR, + Self::simulateForkAndTransfer(_) => { + ::SELECTOR + } + Self::targetArtifactSelectors(_) => { + ::SELECTOR + } + Self::targetArtifacts(_) => { + ::SELECTOR + } + Self::targetContracts(_) => { + ::SELECTOR + } + Self::targetInterfaces(_) => { + ::SELECTOR + } + Self::targetSelectors(_) => { + ::SELECTOR + } + Self::targetSenders(_) => { + ::SELECTOR + } + Self::testAvalonTBTCStrategy(_) => { + ::SELECTOR + } + Self::token(_) => ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn setUp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(AvalonTBTCLendingStrategyForkedCalls::setUp) + } + setUp + }, + { + fn excludeSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonTBTCLendingStrategyForkedCalls::excludeSenders) + } + excludeSenders + }, + { + fn targetInterfaces( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonTBTCLendingStrategyForkedCalls::targetInterfaces) + } + targetInterfaces + }, + { + fn targetSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonTBTCLendingStrategyForkedCalls::targetSenders) + } + targetSenders + }, + { + fn targetContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonTBTCLendingStrategyForkedCalls::targetContracts) + } + targetContracts + }, + { + fn testAvalonTBTCStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + AvalonTBTCLendingStrategyForkedCalls::testAvalonTBTCStrategy, + ) + } + testAvalonTBTCStrategy + }, + { + fn targetArtifactSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + AvalonTBTCLendingStrategyForkedCalls::targetArtifactSelectors, + ) + } + targetArtifactSelectors + }, + { + fn targetArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonTBTCLendingStrategyForkedCalls::targetArtifacts) + } + targetArtifacts + }, + { + fn targetSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonTBTCLendingStrategyForkedCalls::targetSelectors) + } + targetSelectors + }, + { + fn excludeSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonTBTCLendingStrategyForkedCalls::excludeSelectors) + } + excludeSelectors + }, + { + fn excludeArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonTBTCLendingStrategyForkedCalls::excludeArtifacts) + } + excludeArtifacts + }, + { + fn failed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(AvalonTBTCLendingStrategyForkedCalls::failed) + } + failed + }, + { + fn excludeContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonTBTCLendingStrategyForkedCalls::excludeContracts) + } + excludeContracts + }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + AvalonTBTCLendingStrategyForkedCalls::simulateForkAndTransfer, + ) + } + simulateForkAndTransfer + }, + { + fn IS_TEST( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(AvalonTBTCLendingStrategyForkedCalls::IS_TEST) + } + IS_TEST + }, + { + fn token( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(AvalonTBTCLendingStrategyForkedCalls::token) + } + token + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn setUp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonTBTCLendingStrategyForkedCalls::setUp) + } + setUp + }, + { + fn excludeSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonTBTCLendingStrategyForkedCalls::excludeSenders) + } + excludeSenders + }, + { + fn targetInterfaces( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonTBTCLendingStrategyForkedCalls::targetInterfaces) + } + targetInterfaces + }, + { + fn targetSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonTBTCLendingStrategyForkedCalls::targetSenders) + } + targetSenders + }, + { + fn targetContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonTBTCLendingStrategyForkedCalls::targetContracts) + } + targetContracts + }, + { + fn testAvalonTBTCStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + AvalonTBTCLendingStrategyForkedCalls::testAvalonTBTCStrategy, + ) + } + testAvalonTBTCStrategy + }, + { + fn targetArtifactSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + AvalonTBTCLendingStrategyForkedCalls::targetArtifactSelectors, + ) + } + targetArtifactSelectors + }, + { + fn targetArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonTBTCLendingStrategyForkedCalls::targetArtifacts) + } + targetArtifacts + }, + { + fn targetSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonTBTCLendingStrategyForkedCalls::targetSelectors) + } + targetSelectors + }, + { + fn excludeSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonTBTCLendingStrategyForkedCalls::excludeSelectors) + } + excludeSelectors + }, + { + fn excludeArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonTBTCLendingStrategyForkedCalls::excludeArtifacts) + } + excludeArtifacts + }, + { + fn failed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonTBTCLendingStrategyForkedCalls::failed) + } + failed + }, + { + fn excludeContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonTBTCLendingStrategyForkedCalls::excludeContracts) + } + excludeContracts + }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + AvalonTBTCLendingStrategyForkedCalls::simulateForkAndTransfer, + ) + } + simulateForkAndTransfer + }, + { + fn IS_TEST( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonTBTCLendingStrategyForkedCalls::IS_TEST) + } + IS_TEST + }, + { + fn token( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonTBTCLendingStrategyForkedCalls::token) + } + token + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::IS_TEST(inner) => { + ::abi_encoded_size(inner) + } + Self::excludeArtifacts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeContracts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeSenders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::failed(inner) => { + ::abi_encoded_size(inner) + } + Self::setUp(inner) => { + ::abi_encoded_size(inner) + } + Self::simulateForkAndTransfer(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetArtifactSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetArtifacts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetContracts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetInterfaces(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetSenders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::testAvalonTBTCStrategy(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::token(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::IS_TEST(inner) => { + ::abi_encode_raw(inner, out) + } + Self::excludeArtifacts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeContracts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeSenders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::failed(inner) => { + ::abi_encode_raw(inner, out) + } + Self::setUp(inner) => { + ::abi_encode_raw(inner, out) + } + Self::simulateForkAndTransfer(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetArtifactSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetArtifacts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetContracts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetInterfaces(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetSenders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::testAvalonTBTCStrategy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::token(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + ///Container for all the [`AvalonTBTCLendingStrategyForked`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum AvalonTBTCLendingStrategyForkedEvents { + #[allow(missing_docs)] + log(log), + #[allow(missing_docs)] + log_address(log_address), + #[allow(missing_docs)] + log_array_0(log_array_0), + #[allow(missing_docs)] + log_array_1(log_array_1), + #[allow(missing_docs)] + log_array_2(log_array_2), + #[allow(missing_docs)] + log_bytes(log_bytes), + #[allow(missing_docs)] + log_bytes32(log_bytes32), + #[allow(missing_docs)] + log_int(log_int), + #[allow(missing_docs)] + log_named_address(log_named_address), + #[allow(missing_docs)] + log_named_array_0(log_named_array_0), + #[allow(missing_docs)] + log_named_array_1(log_named_array_1), + #[allow(missing_docs)] + log_named_array_2(log_named_array_2), + #[allow(missing_docs)] + log_named_bytes(log_named_bytes), + #[allow(missing_docs)] + log_named_bytes32(log_named_bytes32), + #[allow(missing_docs)] + log_named_decimal_int(log_named_decimal_int), + #[allow(missing_docs)] + log_named_decimal_uint(log_named_decimal_uint), + #[allow(missing_docs)] + log_named_int(log_named_int), + #[allow(missing_docs)] + log_named_string(log_named_string), + #[allow(missing_docs)] + log_named_uint(log_named_uint), + #[allow(missing_docs)] + log_string(log_string), + #[allow(missing_docs)] + log_uint(log_uint), + #[allow(missing_docs)] + logs(logs), + } + #[automatically_derived] + impl AvalonTBTCLendingStrategyForkedEvents { + /// 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]] = &[ + [ + 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, + 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, + 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, + ], + [ + 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, + 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, + 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, + ], + [ + 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, + 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, + 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, + ], + [ + 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, + 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, + 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, + ], + [ + 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, + 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, + 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, + ], + [ + 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, + 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, + 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, + ], + [ + 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, + 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, + 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, + ], + [ + 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, + 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, + 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, + ], + [ + 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, + 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, + 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, + ], + [ + 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, + 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, + 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, + ], + [ + 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, + 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, + 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, + ], + [ + 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, + 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, + 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, + ], + [ + 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, + 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, + 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, + ], + [ + 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, + 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, + 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, + ], + [ + 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, + 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, + 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, + ], + [ + 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, + 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, + 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, + ], + [ + 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, + 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, + 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, + ], + [ + 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, + 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, + 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, + ], + [ + 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, + 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, + 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, + ], + [ + 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, + 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, + 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, + ], + [ + 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, + 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, + 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, + ], + [ + 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, + 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, + 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for AvalonTBTCLendingStrategyForkedEvents { + const NAME: &'static str = "AvalonTBTCLendingStrategyForkedEvents"; + const COUNT: usize = 22usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_address) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_0) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_1) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_2) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_bytes) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_bytes32) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log_int) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_address) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_0) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_1) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_2) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_bytes) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_bytes32) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_decimal_int) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_decimal_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_int) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_string) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_string) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::logs) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 AvalonTBTCLendingStrategyForkedEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::log(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_address(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_0(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_1(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_2(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_bytes(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_address(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_0(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_1(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_2(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_bytes(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_decimal_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_decimal_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_string(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_string(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::logs(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::log(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_address(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_0(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_1(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_2(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_bytes(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_address(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_0(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_1(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_2(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_bytes(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_decimal_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_decimal_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_string(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_string(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::logs(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`AvalonTBTCLendingStrategyForked`](self) contract instance. + +See the [wrapper's documentation](`AvalonTBTCLendingStrategyForkedInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> AvalonTBTCLendingStrategyForkedInstance { + AvalonTBTCLendingStrategyForkedInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + AvalonTBTCLendingStrategyForkedInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + AvalonTBTCLendingStrategyForkedInstance::::deploy_builder(provider) + } + /**A [`AvalonTBTCLendingStrategyForked`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`AvalonTBTCLendingStrategyForked`](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 AvalonTBTCLendingStrategyForkedInstance< + P, + N = alloy_contract::private::Ethereum, + > { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for AvalonTBTCLendingStrategyForkedInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("AvalonTBTCLendingStrategyForkedInstance") + .field(&self.address) + .finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > AvalonTBTCLendingStrategyForkedInstance { + /**Creates a new wrapper around an on-chain [`AvalonTBTCLendingStrategyForked`](self) contract instance. + +See the [wrapper's documentation](`AvalonTBTCLendingStrategyForkedInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 AvalonTBTCLendingStrategyForkedInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider( + self, + ) -> AvalonTBTCLendingStrategyForkedInstance { + AvalonTBTCLendingStrategyForkedInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > AvalonTBTCLendingStrategyForkedInstance { + /// 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( + &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 [`IS_TEST`] function. + pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { + self.call_builder(&IS_TESTCall) + } + ///Creates a new call builder for the [`excludeArtifacts`] function. + pub fn excludeArtifacts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { + self.call_builder(&excludeArtifactsCall) + } + ///Creates a new call builder for the [`excludeContracts`] function. + pub fn excludeContracts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { + self.call_builder(&excludeContractsCall) + } + ///Creates a new call builder for the [`excludeSelectors`] function. + pub fn excludeSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { + self.call_builder(&excludeSelectorsCall) + } + ///Creates a new call builder for the [`excludeSenders`] function. + pub fn excludeSenders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { + self.call_builder(&excludeSendersCall) + } + ///Creates a new call builder for the [`failed`] function. + pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { + self.call_builder(&failedCall) + } + ///Creates a new call builder for the [`setUp`] function. + pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { + self.call_builder(&setUpCall) + } + ///Creates a new call builder for the [`simulateForkAndTransfer`] function. + pub fn simulateForkAndTransfer( + &self, + forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + sender: alloy::sol_types::private::Address, + receiver: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { + self.call_builder( + &simulateForkAndTransferCall { + forkAtBlock, + sender, + receiver, + amount, + }, + ) + } + ///Creates a new call builder for the [`targetArtifactSelectors`] function. + pub fn targetArtifactSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { + self.call_builder(&targetArtifactSelectorsCall) + } + ///Creates a new call builder for the [`targetArtifacts`] function. + pub fn targetArtifacts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { + self.call_builder(&targetArtifactsCall) + } + ///Creates a new call builder for the [`targetContracts`] function. + pub fn targetContracts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { + self.call_builder(&targetContractsCall) + } + ///Creates a new call builder for the [`targetInterfaces`] function. + pub fn targetInterfaces( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { + self.call_builder(&targetInterfacesCall) + } + ///Creates a new call builder for the [`targetSelectors`] function. + pub fn targetSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { + self.call_builder(&targetSelectorsCall) + } + ///Creates a new call builder for the [`targetSenders`] function. + pub fn targetSenders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { + self.call_builder(&targetSendersCall) + } + ///Creates a new call builder for the [`testAvalonTBTCStrategy`] function. + pub fn testAvalonTBTCStrategy( + &self, + ) -> alloy_contract::SolCallBuilder<&P, testAvalonTBTCStrategyCall, N> { + self.call_builder(&testAvalonTBTCStrategyCall) + } + ///Creates a new call builder for the [`token`] function. + pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { + self.call_builder(&tokenCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > AvalonTBTCLendingStrategyForkedInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`log`] event. + pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_address`] event. + pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_0`] event. + pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_1`] event. + pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_2`] event. + pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_bytes`] event. + pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_bytes32`] event. + pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_int`] event. + pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_address`] event. + pub fn log_named_address_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_address, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_0`] event. + pub fn log_named_array_0_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_0, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_1`] event. + pub fn log_named_array_1_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_1, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_2`] event. + pub fn log_named_array_2_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_2, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_bytes`] event. + pub fn log_named_bytes_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_bytes, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_bytes32`] event. + pub fn log_named_bytes32_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_bytes32, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_decimal_int`] event. + pub fn log_named_decimal_int_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_decimal_uint`] event. + pub fn log_named_decimal_uint_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_int`] event. + pub fn log_named_int_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_string`] event. + pub fn log_named_string_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_string, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_uint`] event. + pub fn log_named_uint_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_string`] event. + pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_uint`] event. + pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`logs`] event. + pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/fullrelayisancestortest.rs b/crates/bindings/src/avalon_wbtc_lending_strategy_forked.rs similarity index 63% rename from crates/bindings/src/fullrelayisancestortest.rs rename to crates/bindings/src/avalon_wbtc_lending_strategy_forked.rs index ca9b227bc..f890af4b4 100644 --- a/crates/bindings/src/fullrelayisancestortest.rs +++ b/crates/bindings/src/avalon_wbtc_lending_strategy_forked.rs @@ -837,7 +837,7 @@ library StdInvariant { } } -interface FullRelayIsAncestorTest { +interface AvalonWBTCLendingStrategyForked { event log(string); event log_address(address); event log_array(uint256[] val); @@ -861,37 +861,28 @@ interface FullRelayIsAncestorTest { event log_uint(uint256); event logs(bytes); - constructor(); - function IS_TEST() external view returns (bool); function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); function excludeContracts() external view returns (address[] memory excludedContracts_); function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); function excludeSenders() external view returns (address[] memory excludedSenders_); function failed() external view returns (bool); - function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); - function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); - function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); - function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); + function setUp() external; + function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); function targetArtifacts() external view returns (string[] memory targetedArtifacts_); function targetContracts() external view returns (address[] memory targetedContracts_); function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); function targetSenders() external view returns (address[] memory targetedSenders_); - function testAncestorFound() external view; - function testExceedSearchLimit() external view; + function testAvalonWBTCStrategy() external; + function token() external view returns (address); } ``` ...which was generated by the following JSON ABI: ```json [ - { - "type": "constructor", - "inputs": [], - "stateMutability": "nonpayable" - }, { "type": "function", "name": "IS_TEST", @@ -984,119 +975,38 @@ interface FullRelayIsAncestorTest { }, { "type": "function", - "name": "getBlockHeights", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getDigestLes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes32[]", - "internalType": "bytes32[]" - } - ], - "stateMutability": "view" + "name": "setUp", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" }, { "type": "function", - "name": "getHeaderHexes", + "name": "simulateForkAndTransfer", "inputs": [ { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", + "name": "forkAtBlock", "type": "uint256", "internalType": "uint256" }, { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes[]", - "internalType": "bytes[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaders", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" + "name": "sender", + "type": "address", + "internalType": "address" }, { - "name": "from", - "type": "uint256", - "internalType": "uint256" + "name": "receiver", + "type": "address", + "internalType": "address" }, { - "name": "to", + "name": "amount", "type": "uint256", "internalType": "uint256" } ], - "outputs": [ - { - "name": "headers", - "type": "bytes", - "internalType": "bytes" - } - ], - "stateMutability": "view" + "outputs": [], + "stateMutability": "nonpayable" }, { "type": "function", @@ -1214,16 +1124,22 @@ interface FullRelayIsAncestorTest { }, { "type": "function", - "name": "testAncestorFound", + "name": "testAvalonWBTCStrategy", "inputs": [], "outputs": [], - "stateMutability": "view" + "stateMutability": "nonpayable" }, { "type": "function", - "name": "testExceedSearchLimit", + "name": "token", "inputs": [], - "outputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IERC20" + } + ], "stateMutability": "view" }, { @@ -1599,28 +1515,28 @@ interface FullRelayIsAncestorTest { clippy::style, clippy::empty_structs_with_brackets )] -pub mod FullRelayIsAncestorTest { +pub mod AvalonWBTCLendingStrategyForked { use super::*; use alloy::sol_types as alloy_sol_types; /// 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`@R`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U`\x06`#U4\x80\x15a\x001W__\xFD[P`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k42\xB0\xB22\xB99\x9759\xB7\xB7`\xA1\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k\x05\xCC\xEC\xAD\xCC\xAEm.e\xCD\x0C\xAF`\xA3\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x0F\x81R` \x01n\x0B\x99\xD9[\x99\\\xDA\\\xCB\x9A\x19ZY\xDA\x1D`\x8A\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01q.genesis.digest_le`p\x1B\x81RP__Q` aU\x9D_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x16c\xD90\xA0\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\x18W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01?\x91\x90\x81\x01\x90a\x0B\x02V[\x90P_\x81\x86`@Q` \x01a\x01U\x92\x91\x90a\x0B]V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Rc`\xF9\xBB\x11`\xE0\x1B\x82R\x91P_Q` aU\x9D_9_Q\x90_R\x90c`\xF9\xBB\x11\x90a\x01\x95\x90\x84\x90`\x04\x01a\x0B\xCFV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xAFW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01\xD6\x91\x90\x81\x01\x90a\x0B\x02V[` \x90a\x01\xE3\x90\x82a\x0CeV[Pa\x02z\x85` \x80Ta\x01\xF5\x90a\x0B\xE1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02!\x90a\x0B\xE1V[\x80\x15a\x02lW\x80`\x1F\x10a\x02CWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02lV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02OW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x05v\x91PPV[a\x03\x10\x85` \x80Ta\x02\x8B\x90a\x0B\xE1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\xB7\x90a\x0B\xE1V[\x80\x15a\x03\x02W\x80`\x1F\x10a\x02\xD9Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\x02V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02\xE5W\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x05\xF5\x91PPV[a\x03\xA6\x85` \x80Ta\x03!\x90a\x0B\xE1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03M\x90a\x0B\xE1V[\x80\x15a\x03\x98W\x80`\x1F\x10a\x03oWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\x98V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03{W\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x06h\x91PPV[`@Qa\x03\xB2\x90a\n\x0FV[a\x03\xBE\x93\x92\x91\x90a\r\x1FV[`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03\xD7W=__>=_\xFD[P`\x1F`\x01a\x01\0\n\x81T\x81`\x01`\x01`\xA0\x1B\x03\x02\x19\x16\x90\x83`\x01`\x01`\xA0\x1B\x03\x16\x02\x17\x90UPPPPPPPa\x044`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01d1\xB40\xB4\xB7`\xD9\x1B\x81RP_`#Ta\x06\x9C` \x1B` \x1CV[\x80Qa\x04H\x91`\"\x91` \x90\x91\x01\x90a\n\x1CV[Pa\x04\x84`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01q.genesis.digest_le`p\x1B\x81RP` \x80Ta\x03!\x90a\x0B\xE1V[`!\x81\x90UP`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16ce\xDAA\xB9a\x04\xE3`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k\x05\xCC\xEC\xAD\xCC\xAEm.e\xCD\x0C\xAF`\xA3\x1B\x81RP` \x80Ta\x01\xF5\x90a\x0B\xE1V[a\x05\x13`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01d1\xB40\xB4\xB7`\xD9\x1B\x81RP_`#Ta\x06\xD9` \x1B` \x1CV[`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x050\x92\x91\x90a\rCV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x05LW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05p\x91\x90a\rgV[Pa\x0E\xA2V[`@Qc\x1F\xB2C}`\xE3\x1B\x81R``\x90_Q` aU\x9D_9_Q\x90_R\x90c\xFD\x92\x1B\xE8\x90a\x05\xAB\x90\x86\x90\x86\x90`\x04\x01a\rCV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xC5W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x05\xEC\x91\x90\x81\x01\x90a\x0B\x02V[\x90P[\x92\x91PPV[`@QcV\xEE\xF1[`\xE1\x1B\x81R_\x90_Q` aU\x9D_9_Q\x90_R\x90c\xAD\xDD\xE2\xB6\x90a\x06)\x90\x86\x90\x86\x90`\x04\x01a\rCV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06DW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xEC\x91\x90a\r\x8DV[`@Qc\x17w\xE5\x9D`\xE0\x1B\x81R_\x90_Q` aU\x9D_9_Q\x90_R\x90c\x17w\xE5\x9D\x90a\x06)\x90\x86\x90\x86\x90`\x04\x01a\rCV[``a\x06\xD1\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01hdigest_le`\xB8\x1B\x81RPa\x07K` \x1B` \x1CV[\x94\x93PPPPV[``_a\x06\xE7\x85\x85\x85a\x08\x17V[\x90P_[a\x06\xF5\x85\x85a\r\xB8V[\x81\x10\x15a\x07BW\x82\x82\x82\x81Q\x81\x10a\x07\x0FWa\x07\x0Fa\r\xCBV[` \x02` \x01\x01Q`@Q` \x01a\x07(\x92\x91\x90a\r\xDFV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x06\xEBV[PP\x93\x92PPPV[``a\x07W\x84\x84a\r\xB8V[`\x01`\x01`@\x1B\x03\x81\x11\x15a\x07nWa\x07na\nyV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x07\x97W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x08\x0EWa\x07\xE0\x86a\x07\xB1\x83a\x08FV[\x85`@Q` \x01a\x07\xC4\x93\x92\x91\x90a\r\xF3V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x03!\x90a\x0B\xE1V[\x82a\x07\xEB\x87\x84a\r\xB8V[\x81Q\x81\x10a\x07\xFBWa\x07\xFBa\r\xCBV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x07\x9CV[P\x94\x93PPPPV[``a\x06\xD1\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01b\r\x0C\xAF`\xEB\x1B\x81RPa\tB` \x1B` \x1CV[``\x81_\x03a\x08lWPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R`\x03`\xFC\x1B` \x82\x01R\x90V[\x81_[\x81\x15a\x08\x95W\x80a\x08\x7F\x81a\x0E=V[\x91Pa\x08\x8E\x90P`\n\x83a\x0EiV[\x91Pa\x08oV[_\x81`\x01`\x01`@\x1B\x03\x81\x11\x15a\x08\xAEWa\x08\xAEa\nyV[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x08\xD8W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x06\xD1Wa\x08\xED`\x01\x83a\r\xB8V[\x91Pa\x08\xFA`\n\x86a\x0E|V[a\t\x05\x90`0a\x0E\x8FV[`\xF8\x1B\x81\x83\x81Q\x81\x10a\t\x1AWa\t\x1Aa\r\xCBV[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SPa\t;`\n\x86a\x0EiV[\x94Pa\x08\xDCV[``a\tN\x84\x84a\r\xB8V[`\x01`\x01`@\x1B\x03\x81\x11\x15a\teWa\tea\nyV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\t\x98W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\t\x83W\x90P[P\x90P\x83[\x83\x81\x10\x15a\x08\x0EWa\t\xE1\x86a\t\xB2\x83a\x08FV[\x85`@Q` \x01a\t\xC5\x93\x92\x91\x90a\r\xF3V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x01\xF5\x90a\x0B\xE1V[\x82a\t\xEC\x87\x84a\r\xB8V[\x81Q\x81\x10a\t\xFCWa\t\xFCa\r\xCBV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\t\x9DV[a);\x80a,b\x839\x01\x90V[\x82\x80T\x82\x82U\x90_R` _ \x90\x81\x01\x92\x82\x15a\nUW\x91` \x02\x82\x01[\x82\x81\x11\x15a\nUW\x82Q\x82U\x91` \x01\x91\x90`\x01\x01\x90a\n:V[Pa\na\x92\x91Pa\neV[P\x90V[[\x80\x82\x11\x15a\naW_\x81U`\x01\x01a\nfV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x80`\x01`\x01`@\x1B\x03\x84\x11\x15a\n\xA6Wa\n\xA6a\nyV[P`@Q`\x1F\x19`\x1F\x85\x01\x81\x16`?\x01\x16\x81\x01\x81\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17\x15a\n\xD4Wa\n\xD4a\nyV[`@R\x83\x81R\x90P\x80\x82\x84\x01\x85\x10\x15a\n\xEBW__\xFD[\x83\x83` \x83\x01^_` \x85\x83\x01\x01RP\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x0B\x12W__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x0B'W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x0B7W__\xFD[a\x06\xD1\x84\x82Q` \x84\x01a\n\x8DV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x0Bh\x82\x85a\x0BFV[\x7F/test/fullRelay/testData/\0\0\0\0\0\0\0\x81Ra\x0B\x98`\x19\x82\x01\x85a\x0BFV[\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R_a\x05\xEC` \x83\x01\x84a\x0B\xA1V[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x0B\xF5W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x0C\x13WcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\x0C`W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x0C>WP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x0C]W_\x81U`\x01\x01a\x0CJV[PP[PPPV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x0C~Wa\x0C~a\nyV[a\x0C\x92\x81a\x0C\x8C\x84Ta\x0B\xE1V[\x84a\x0C\x19V[` `\x1F\x82\x11`\x01\x81\x14a\x0C\xC4W_\x83\x15a\x0C\xADWP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x0C]V[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x0C\xF3W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x0C\xD3V[P\x84\x82\x10\x15a\r\x10W\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[``\x81R_a\r1``\x83\x01\x86a\x0B\xA1V[` \x83\x01\x94\x90\x94RP`@\x01R\x91\x90PV[`@\x81R_a\rU`@\x83\x01\x85a\x0B\xA1V[\x82\x81\x03` \x84\x01Ra\x0B\x98\x81\x85a\x0B\xA1V[_` \x82\x84\x03\x12\x15a\rwW__\xFD[\x81Q\x80\x15\x15\x81\x14a\r\x86W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\r\x9DW__\xFD[PQ\x91\x90PV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x05\xEFWa\x05\xEFa\r\xA4V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[_a\x06\xD1a\r\xED\x83\x86a\x0BFV[\x84a\x0BFV[`\x17`\xF9\x1B\x81R_a\x0E\x08`\x01\x83\x01\x86a\x0BFV[`[`\xF8\x1B\x81Ra\x0E\x1C`\x01\x82\x01\x86a\x0BFV[\x90Pa.\x97`\xF1\x1B\x81Ra\x0E3`\x02\x82\x01\x85a\x0BFV[\x96\x95PPPPPPV[_`\x01\x82\x01a\x0ENWa\x0ENa\r\xA4V[P`\x01\x01\x90V[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x0EwWa\x0Ewa\x0EUV[P\x04\x90V[_\x82a\x0E\x8AWa\x0E\x8Aa\x0EUV[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a\x05\xEFWa\x05\xEFa\r\xA4V[a\x1D\xB3\x80a\x0E\xAF_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01/W_5`\xE0\x1C\x80cq\xF5\x13/\x11a\0\xADW\x80c\xB5P\x8A\xA9\x11a\0}W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x02OW\x80c\xFAv&\xD4\x14a\x02WW\x80c\xFA\xD0k\x8F\x14a\x02dW__\xFD[\x80c\xB5P\x8A\xA9\x14a\x02/W\x80c\xBAAO\xA6\x14a\x027W__\xFD[\x80cq\xF5\x13/\x14a\x01\xF5W\x80c\x85\"l\x81\x14a\x01\xFDW\x80c\x91j\x17\xC6\x14a\x02\x12W\x80c\xB0FO\xDC\x14a\x02'W__\xFD[\x80c>^<#\x11a\x01\x02W\x80cD\xBA\xDB\xB6\x11a\0\xE8W\x80cD\xBA\xDB\xB6\x14a\x01\xB6W\x80cP\xB9\xC5N\x14a\x01\xD6W\x80cf\xD9\xA9\xA0\x14a\x01\xE0W__\xFD[\x80c>^<#\x14a\x01\xA6W\x80c?r\x86\xF4\x14a\x01\xAEW__\xFD[\x80c\x08\x13\x85*\x14a\x013W\x80c\x1C\r\xA8\x1F\x14a\x01\\W\x80c\x1E\xD7\x83\x1C\x14a\x01|W\x80c*\xDE8\x80\x14a\x01\x91W[__\xFD[a\x01Fa\x01A6`\x04a\x16tV[a\x02wV[`@Qa\x01S\x91\x90a\x17)V[`@Q\x80\x91\x03\x90\xF3[a\x01oa\x01j6`\x04a\x16tV[a\x02\xC2V[`@Qa\x01S\x91\x90a\x17\x8CV[a\x01\x84a\x034V[`@Qa\x01S\x91\x90a\x17\x9EV[a\x01\x99a\x03\xA1V[`@Qa\x01S\x91\x90a\x18PV[a\x01\x84a\x04\xEAV[a\x01\x84a\x05UV[a\x01\xC9a\x01\xC46`\x04a\x16tV[a\x05\xC0V[`@Qa\x01S\x91\x90a\x18\xD4V[a\x01\xDEa\x06\x03V[\0[a\x01\xE8a\x06\xEFV[`@Qa\x01S\x91\x90a\x19gV[a\x01\xDEa\x08hV[a\x02\x05a\tRV[`@Qa\x01S\x91\x90a\x19\xE5V[a\x02\x1Aa\n\x1DV[`@Qa\x01S\x91\x90a\x19\xF7V[a\x02\x1Aa\x0B V[a\x02\x05a\x0C#V[a\x02?a\x0C\xEEV[`@Q\x90\x15\x15\x81R` \x01a\x01SV[a\x01\x84a\r\xBEV[`\x1FTa\x02?\x90`\xFF\x16\x81V[a\x01\xC9a\x02r6`\x04a\x16tV[a\x0E)V[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x0ElV[\x94\x93PPPPV[``_a\x02\xD0\x85\x85\x85a\x02wV[\x90P_[a\x02\xDE\x85\x85a\x1A\xA8V[\x81\x10\x15a\x03+W\x82\x82\x82\x81Q\x81\x10a\x02\xF8Wa\x02\xF8a\x1A\xBBV[` \x02` \x01\x01Q`@Q` \x01a\x03\x11\x92\x91\x90a\x1A\xFFV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x02\xD4V[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\xCAW\x83\x82\x90_R` _ \x01\x80Ta\x04?\x90a\x1B\x13V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x04k\x90a\x1B\x13V[\x80\x15a\x04\xB6W\x80`\x1F\x10a\x04\x8DWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x04\xB6V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x04\x99W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x04\"V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x03\xC4V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x0F\xCDV[a\x06\xED`\x1F`\x01\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\xB9\x85b\x1A`!T`\"`\x03\x81T\x81\x10a\x06[Wa\x06[a\x1A\xBBV[_\x91\x82R` \x90\x91 \x01T`@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\x81R`\x04\x81\x01\x92\x90\x92R`$\x82\x01R`\x01`D\x82\x01R`d\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xC4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xE8\x91\x90a\x1BdV[a\x11\x1BV[V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x07B\x90a\x1B\x13V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07n\x90a\x1B\x13V[\x80\x15a\x07\xB9W\x80`\x1F\x10a\x07\x90Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07\xB9V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\x9CW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x08PW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x07\xFDW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07\x12V[a\x06\xED`\x1F`\x01\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\xB9\x85b\x1A`!T`\"`\x03\x81T\x81\x10a\x08\xC0Wa\x08\xC0a\x1A\xBBV[_\x91\x82R` \x90\x91 \x01T`@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\x81R`\x04\x81\x01\x92\x90\x92R`$\x82\x01R`\x05`D\x82\x01R`d\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\t)W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\tM\x91\x90a\x1BdV[a\x11\x98V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x01\x80Ta\t\x92\x90a\x1B\x13V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\t\xBE\x90a\x1B\x13V[\x80\x15a\n\tW\x80`\x1F\x10a\t\xE0Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\tV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t\xECW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\tuV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0B\x08W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\n\xB5W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\n@V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\x0BW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0B\xB8W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0BCV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x01\x80Ta\x0Cc\x90a\x1B\x13V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C\x8F\x90a\x1B\x13V[\x80\x15a\x0C\xDAW\x80`\x1F\x10a\x0C\xB1Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C\xDAV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0C\xBDW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0CFV[`\x08T_\x90`\xFF\x16\x15a\r\x05WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\r\x93W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\xB7\x91\x90a\x1B\x8AV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x11\xEAV[``a\x0Ex\x84\x84a\x1A\xA8V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0E\x90Wa\x0E\x90a\x15\xEFV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0E\xC3W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x0E\xAEW\x90P[P\x90P\x83[\x83\x81\x10\x15a\x0F\xC4Wa\x0F\x96\x86a\x0E\xDD\x83a\x138V[\x85`@Q` \x01a\x0E\xF0\x93\x92\x91\x90a\x1B\xA1V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x0F\x0C\x90a\x1B\x13V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F8\x90a\x1B\x13V[\x80\x15a\x0F\x83W\x80`\x1F\x10a\x0FZWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F\x83V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0FfW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x14i\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x0F\xA1\x87\x84a\x1A\xA8V[\x81Q\x81\x10a\x0F\xB1Wa\x0F\xB1a\x1A\xBBV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x0E\xC8V[P\x94\x93PPPPV[``a\x0F\xD9\x84\x84a\x1A\xA8V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0F\xF1Wa\x0F\xF1a\x15\xEFV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x10\x1AW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x0F\xC4Wa\x10\xED\x86a\x104\x83a\x138V[\x85`@Q` \x01a\x10G\x93\x92\x91\x90a\x1B\xA1V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x10c\x90a\x1B\x13V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x10\x8F\x90a\x1B\x13V[\x80\x15a\x10\xDAW\x80`\x1F\x10a\x10\xB1Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x10\xDAV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x10\xBDW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x15\x08\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x10\xF8\x87\x84a\x1A\xA8V[\x81Q\x81\x10a\x11\x08Wa\x11\x08a\x1A\xBBV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x10\x1FV[`@Q\x7F\xA5\x98(\x85\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x81\x15\x15`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xA5\x98(\x85\x90`$\x01[_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x11\x7FW__\xFD[PZ\xFA\x15\x80\x15a\x11\x91W=__>=_\xFD[PPPPPV[`@Q\x7F\x0C\x9F\xD5\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\x81R\x81\x15\x15`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x0C\x9F\xD5\x81\x90`$\x01a\x11iV[``a\x11\xF6\x84\x84a\x1A\xA8V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\x0EWa\x12\x0Ea\x15\xEFV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x127W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x0F\xC4Wa\x13\n\x86a\x12Q\x83a\x138V[\x85`@Q` \x01a\x12d\x93\x92\x91\x90a\x1B\xA1V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x12\x80\x90a\x1B\x13V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x12\xAC\x90a\x1B\x13V[\x80\x15a\x12\xF7W\x80`\x1F\x10a\x12\xCEWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x12\xF7V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x12\xDAW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x15\x9B\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x13\x15\x87\x84a\x1A\xA8V[\x81Q\x81\x10a\x13%Wa\x13%a\x1A\xBBV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x12V[\x91Pa\x13\x9C\x90P`\n\x83a\x1C\xA2V[\x91Pa\x13}V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x13\xBDWa\x13\xBDa\x15\xEFV[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x13\xE7W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x02\xBAWa\x13\xFC`\x01\x83a\x1A\xA8V[\x91Pa\x14\t`\n\x86a\x1C\xB5V[a\x14\x14\x90`0a\x1C\xC8V[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x14)Wa\x14)a\x1A\xBBV[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x14b`\n\x86a\x1C\xA2V[\x94Pa\x13\xEBV[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a\x14\xBE\x90\x86\x90\x86\x90`\x04\x01a\x1C\xDBV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x14\xD8W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x14\xFF\x91\x90\x81\x01\x90a\x1D\x08V[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x15\\\x90\x86\x90\x86\x90`\x04\x01a\x1C\xDBV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x15wW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x14\xFF\x91\x90a\x1B\x8AV[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x15\\\x90\x86\x90\x86\x90`\x04\x01a\x1C\xDBV[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x16EWa\x16Ea\x15\xEFV[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x16fWa\x16fa\x15\xEFV[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x16\x86W__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\x9CW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x16\xACW__\xFD[\x805a\x16\xBFa\x16\xBA\x82a\x16MV[a\x16\x1CV[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x16\xD3W__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x17\x80W`?\x19\x87\x86\x03\x01\x84Ra\x17k\x85\x83Qa\x16\xFBV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x17OV[P\x92\x96\x95PPPPPPV[` \x81R_a\x14\xFF` \x83\x01\x84a\x16\xFBV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x17\xEBW\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\x17\xB7V[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x18DW`\x1F\x19\x85\x84\x03\x01\x88Ra\x18.\x83\x83Qa\x16\xFBV[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x18\x12V[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x17\x80W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x18\xBE`@\x87\x01\x82a\x17\xF6V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x18vV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x17\xEBW\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x18\xEDV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x19]W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x19\x1DV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x17\x80W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x19\xB3`@\x88\x01\x82a\x16\xFBV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x19\xCE\x81\x83a\x19\x0BV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x19\x8DV[` \x81R_a\x14\xFF` \x83\x01\x84a\x17\xF6V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x17\x80W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1Ae`@\x87\x01\x82a\x19\x0BV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1A\x1DV[\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\x15\x02Wa\x15\x02a\x1A{V[\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x02\xBAa\x1B\r\x83\x86a\x1A\xE8V[\x84a\x1A\xE8V[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1B'W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x1B^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`\"`\x04R`$_\xFD[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x1BtW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x1B\x83W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x1B\x9AW__\xFD[PQ\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\x81R_a\x1B\xD2`\x01\x83\x01\x86a\x1A\xE8V[\x7F[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x1C\x02`\x01\x82\x01\x86a\x1A\xE8V[\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\x81Ra\x1C4`\x02\x82\x01\x85a\x1A\xE8V[\x96\x95PPPPPPV[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x1CnWa\x1Cna\x1A{V[P`\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`\x12`\x04R`$_\xFD[_\x82a\x1C\xB0Wa\x1C\xB0a\x1CuV[P\x04\x90V[_\x82a\x1C\xC3Wa\x1C\xC3a\x1CuV[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a\x15\x02Wa\x15\x02a\x1A{V[`@\x81R_a\x1C\xED`@\x83\x01\x85a\x16\xFBV[\x82\x81\x03` \x84\x01Ra\x1C\xFF\x81\x85a\x16\xFBV[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x1D\x18W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D.W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x1D>W__\xFD[\x80Qa\x1DLa\x16\xBA\x82a\x16MV[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a\x1D`W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV\xFE\xA2dipfsX\"\x12 \x90Y\xC3\x96\x11M\xB9\x01'\xAC\xC5\xA1\x9D\xB2\xA3\xC0lf\xCD\xC7\x86zg\x12\x8B\x82\x84\xAE\xA6$,`dsolcC\0\x08\x1C\x003`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa);8\x03\x80a);\x839\x81\x01`@\x81\x90Ra\0.\x91a\x03+V[\x82\x82\x82\x82\x82\x82a\0?\x83Q`P\x14\x90V[a\0\x84W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x11`$\x82\x01RpBad genesis block`x\x1B`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\0\x8E\x84a\x01fV[\x90Pb\xFF\xFF\xFF\x82\x16\x15a\x01\tW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FPeriod start hash does not have `D\x82\x01R\x7Fwork. Hint: wrong byte order?\0\0\0`d\x82\x01R`\x84\x01a\0{V[_\x81\x81U`\x01\x82\x90U`\x02\x82\x90U\x81\x81R`\x04` R`@\x90 \x83\x90Ua\x012a\x07\xE0\x84a\x03\xFEV[a\x01<\x90\x84a\x04%V[_\x83\x81R`\x04` R`@\x90 Ua\x01S\x84a\x02&V[`\x05UPa\x05\xBD\x98PPPPPPPPPV[_`\x02\x80\x83`@Qa\x01x\x91\x90a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\x93W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x04NV[`@Q` \x01a\x01\xC8\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x01\xE2\x91a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\xFDW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02 \x91\x90a\x04NV[\x92\x91PPV[_a\x02 a\x023\x83a\x028V[a\x02CV[_a\x02 \x82\x82a\x02SV[_a\x02 a\xFF\xFF`\xD0\x1B\x83a\x02\xF7V[_\x80a\x02ja\x02c\x84`Ha\x04eV[\x85\x90a\x03\tV[`\xE8\x1C\x90P_\x84a\x02|\x85`Ka\x04eV[\x81Q\x81\x10a\x02\x8CWa\x02\x8Ca\x04xV[\x01` \x01Q`\xF8\x1C\x90P_a\x02\xBE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x02\xD1`\x03\x84a\x04\x8CV[`\xFF\x16\x90Pa\x02\xE2\x81a\x01\0a\x05\x88V[a\x02\xEC\x90\x83a\x05\x93V[\x97\x96PPPPPPPV[_a\x03\x02\x82\x84a\x05\xAAV[\x93\x92PPPV[_a\x03\x02\x83\x83\x01` \x01Q\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x03=W__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03RW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03bW__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03{Wa\x03{a\x03\x17V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x03\xA9Wa\x03\xA9a\x03\x17V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x03\xC0W__\xFD[\x81` \x84\x01` \x83\x01^_` \x92\x82\x01\x83\x01R\x90\x86\x01Q`@\x90\x96\x01Q\x90\x97\x95\x96P\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x04\x0CWa\x04\x0Ca\x03\xEAV[P\x06\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x04^W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02 Wa\x02 a\x04\x11V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[`\x01\x81[`\x01\x84\x11\x15a\x04\xE0W\x80\x85\x04\x81\x11\x15a\x04\xC4Wa\x04\xC4a\x04\x11V[`\x01\x84\x16\x15a\x04\xD2W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x04\xA9V[\x93P\x93\x91PPV[_\x82a\x04\xF6WP`\x01a\x02 V[\x81a\x05\x02WP_a\x02 V[\x81`\x01\x81\x14a\x05\x18W`\x02\x81\x14a\x05\"Wa\x05>V[`\x01\x91PPa\x02 V[`\xFF\x84\x11\x15a\x053Wa\x053a\x04\x11V[PP`\x01\x82\x1Ba\x02 V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x05aWP\x81\x81\na\x02 V[a\x05m_\x19\x84\x84a\x04\xA5V[\x80_\x19\x04\x82\x11\x15a\x05\x80Wa\x05\x80a\x04\x11V[\x02\x93\x92PPPV[_a\x03\x02\x83\x83a\x04\xE8V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x02 Wa\x02 a\x04\x11V[_\x82a\x05\xB8Wa\x05\xB8a\x03\xEAV[P\x04\x90V[a#q\x80a\x05\xCA_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\xADW\x80c\xB9\x85b\x1A\x11a\0}W\x80c\xE3\xD8\xD8\xD8\x11a\0cW\x80c\xE3\xD8\xD8\xD8\x14a\x02\"W\x80c\xE4q\xE7,\x14a\x02)W\x80c\xF5\x8D\xB0o\x14a\x02=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x13\x91\x90a!WV[`@Q` \x01a\x0C%\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\x90\x82\x90Ra\x0C]\x91a!AV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0CxW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x07\x91\x90a!WV[_\x83\x85\x14\x80\x15a\x0C\xAAWP\x82\x85\x14[\x15a\x0C\xB7WP`\x01a\x04\xF1V[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x0C\xFFW\x89\x83\x14a\x0C\xDEW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x0C\xF7W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x0C\xBDV[P\x82\x84\x03a\r\x13W_\x94PPPPPa\x04\xF1V[\x80\x82\x14a\r&W_\x94PPPPPa\x04\xF1V[P`\x01\x98\x97PPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\rYW_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\r9V[P\x80a\x05\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x80\x82\x81[a\r\xB8`\x04`\x01a!\x9BV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0E\x0CW_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\r\xF1W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0E\x04V[a\r\xFB\x81\x84a!\xB7V[\x95\x94PPPPPV[`\x01\x01a\r\xACV[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_`P\x82Qa\x0B~\x91\x90a!.V[__a\x0Eo\x85a\x0B\xC3V[\x90P_a\x0E{\x82a\r\xA7V[\x90P_a\x0E\x87\x86a\x19\xE6V[\x90P\x84\x80a\x0E\x9CWP\x80a\x0E\x9A\x88a\x19\xE6V[\x14[a\x0F\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x03.V[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x12\x0EWa\x0F(`P\x82a!\xCAV[a\x0F3\x90`\x01a!\xB7V[a\x0F=\x90\x87a!\xB7V[\x93Pa\x0FK\x8A\x82`Pa\x19\xF1V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x11!W\x84a\x10\xA1\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x10\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x11\n`\x04\x85a!.V[_\x03a\x11!W_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x11,\x8B\x83a\x1A\x16V[\x14a\x11yW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[\x86a\x11\x84\x8B\x83a\x1A\xAFV[\x14a\x11\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x03.V[\x82\x96P`P\x81a\x12\x07\x91\x90a!\xB7V[\x90Pa\x0F\x15V[P\x81a\x12\x19\x8Ba\x0B\xC3V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x12\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x12\xD4\x84a\x0B\xC3V[\x90P_a\x12\xE0\x86a\x0B\xC3V[\x90P`\x01T\x81\x14a\x133W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x03.V[_\x82\x81R`\x03` R`@\x90 Ta\x13\x8DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x13\x9B\x87`\x01T\x84\x87a\x0C\x9BV[a\x14\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x03.V[\x81a\x14\x19\x88\x88\x88a\x17\x80V[\x14a\x14\x8CW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[`\x01\x82\x90U`\x02\x87\x90U_a\x14\xA0\x86a\x1A\xC7V[\x90P`\x05T\x81\x14a\x14\xB1W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x15\x01a\x14\xFC\x86a\x0B\xC3V[a\r\xA7V[\x90P_a\x15\x10a\x14\xFC\x86a\x0B\xC3V[\x90Pa\x15\x1Ea\x07\xE0\x82a!.V[a\x07\xDF\x14a\x15\x94W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x03.V[a\x15\xA0\x82a\x07\xDFa!\xB7V[\x81\x14a\x16\x14W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x03.V[a\x16\x1D\x85a\x1A\xC7V[a\x16&\x87a\x1A\xC7V[\x14a\x16\x99W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x03.V[_a\x16\xA3\x85a\x19\xE6V[\x90P_a\x16\xD5a\x16\xB2\x89a\x19\xE6V[a\x16\xBB\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x16\xCA\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x1B\x0CV[\x90P\x81\x81\x83\x16\x14a\x17(W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_a\x172\x89a\x1A\xC7V[\x90P\x80`\x06T\x14\x15\x80\x15a\x17\\WPa\x07\xE0a\x17O`\x01Ta\r\xA7V[a\x17Y\x91\x90a!\xDDV[\x84\x11[\x15a\x17gW`\x06\x81\x90U[a\x17s\x88\x88`\x01a\x0EdV[\x99\x98PPPPPPPPPV[__a\x17\x8B\x85a\r\xA7V[\x90P_a\x17\x9Aa\x14\xFC\x86a\x0B\xC3V[\x90P_a\x17\xA9a\x14\xFC\x86a\x0B\xC3V[\x90P\x82\x82\x10\x15\x80\x15a\x17\xBBWP\x82\x81\x10\x15[a\x18-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x18:a\x07\xE0\x85a!.V[a\x18F\x85a\x07\xE0a!\xB7V[a\x18P\x91\x90a!\xDDV[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x18bWP\x80[\x15a\x18}Wa\x18p\x89a\x0B\xC3V[\x96PPPPPPPa\n\xA3V[\x81\x80\x15a\x18\x88WP\x80\x15[\x15a\x18\x96Wa\x18p\x88a\x0B\xC3V[\x81\x80\x15a\x18\xA0WP\x80[\x15a\x18\xC4W\x83\x85\x10\x15a\x18\xBBWa\x18\xB6\x88a\x0B\xC3V[a\x18pV[a\x18p\x89a\x0B\xC3V[a\x18\xCD\x88a\x1A\xC7V[a\x18\xD9a\x07\xE0\x86a!.V[a\x18\xE3\x91\x90a!\xF0V[a\x18\xEC\x8Aa\x1A\xC7V[a\x18\xF8a\x07\xE0\x88a!.V[a\x19\x02\x91\x90a!\xF0V[\x10\x15a\x18\xBBWa\x18p\x88a\x0B\xC3V[`\x07T_\x90`\xFF\x16\x15a\x19/WP`\x07Ta\x01\0\x90\x04`\xFF\x16a\n\xA3V[a\x19:\x84\x84\x84a\x1B\x94V[\x90Pa\n\xA3V[_` \x84Qa\x19P\x91\x90a!.V[\x15a\x19\\WP_a\x04\xF1V[\x83Q_\x03a\x19kWP_a\x04\xF1V[\x81\x85_[\x86Q\x81\x10\x15a\x19\xD9Wa\x19\x83`\x02\x84a!.V[`\x01\x03a\x19\xA7Wa\x19\xA0a\x19\x9A\x88\x83\x01` \x01Q\x90V[\x83a\x1B\xD5V[\x91Pa\x19\xC0V[a\x19\xBD\x82a\x19\xB8\x89\x84\x01` \x01Q\x90V[a\x1B\xD5V[\x91P[`\x01\x92\x90\x92\x1C\x91a\x19\xD2` \x82a!\xB7V[\x90Pa\x19oV[P\x90\x93\x14\x95\x94PPPPPV[_a\x05\x07\x82_a\x1A\x16V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x1A-a\x1A&\x84`Ha!\xB7V[\x85\x90a\x1B\xE0V[`\xE8\x1C\x90P_\x84a\x1A?\x85`Ka!\xB7V[\x81Q\x81\x10a\x1AOWa\x1AOa\"\x07V[\x01` \x01Q`\xF8\x1C\x90P_a\x1A\x81\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1A\x94`\x03\x84a\"4V[`\xFF\x16\x90Pa\x1A\xA5\x81a\x01\0a#0V[a\x08-\x90\x83a!\xF0V[_a\x05\x04a\x1A\xBE\x83`\x04a!\xB7V[\x84\x01` \x01Q\x90V[_a\x05\x07a\x1A\xD4\x83a\x19\xE6V[a\x1B\xEEV[_a\x05\x07a\x1A\xE6\x83a\x1C\x15V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1B\x18\x83\x85a\x1C!V[\x90Pa\x1B(b\x12u\0`\x04a\x1C|V[\x81\x10\x15a\x1B@Wa\x1B=b\x12u\0`\x04a\x1C|V[\x90P[a\x1BNb\x12u\0`\x04a\x1C\x87V[\x81\x11\x15a\x1BfWa\x1Bcb\x12u\0`\x04a\x1C\x87V[\x90P[_a\x1B~\x82a\x1Bx\x88b\x01\0\0a\x1C|V[\x90a\x1C\x87V[\x90Pa\n\x8Ab\x01\0\0a\x1Bx\x83b\x12u\0a\x1C|V[_\x82\x81[\x83\x81\x10\x15a\x1B\xCAW\x85\x82\x03a\x1B\xB2W`\x01\x92PPPa\n\xA3V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x1B\x98V[P_\x95\x94PPPPPV[_a\x05\x04\x83\x83a\x1C\xFAV[_a\x05\x04\x83\x83\x01` \x01Q\x90V[_a\x05\x07{\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\x83a\x1C|V[_a\x05\x07\x82`Da\x1B\xE0V[_\x82\x82\x11\x15a\x1CrW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x05\x04\x82\x84a!\xDDV[_a\x05\x04\x82\x84a!\xCAV[_\x82_\x03a\x1C\x96WP_a\x05\x07V[a\x1C\xA0\x82\x84a!\xF0V[\x90P\x81a\x1C\xAD\x84\x83a!\xCAV[\x14a\x05\x07W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x03.V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1D1W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DHW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1D_W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1DvW__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1D\x91W__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xA7W__\xFD[a\x1D\xB3\x8A\x82\x8B\x01a\x1D!V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xD2W__\xFD[a\x1D\xDE\x8A\x82\x8B\x01a\x1D!V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1D\xFE`\x80\x89\x01a\x1DfV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[____`\x80\x85\x87\x03\x12\x15a\x1E\x1FW__\xFD[PP\x825\x94` \x84\x015\x94P`@\x84\x015\x93``\x015\x92P\x90PV[__`@\x83\x85\x03\x12\x15a\x1ELW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1EkW__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1E\x85W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x9BW__\xFD[a\x1E\xA7\x87\x82\x88\x01a\x1D!V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\xC6W__\xFD[a\x1E\xD2\x87\x82\x88\x01a\x1D!V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1E\xF3W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x10W__\xFD[a\x1F\x1C\x89\x82\x8A\x01a\x1D!V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F;W__\xFD[a\x1FG\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1FtW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x8AW__\xFD[a\x1F\x96\x89\x82\x8A\x01a\x1D!V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xB5W__\xFD[a\x1F\xC1\x89\x82\x8A\x01a\x1D!V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xE0W__\xFD[a\x1F\xEC\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_____``\x86\x88\x03\x12\x15a \x12W__\xFD[\x855\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a /W__\xFD[a ;\x88\x82\x89\x01a\x1D!V[\x90\x95P\x93PP`@\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a ZW__\xFD[a f\x88\x82\x89\x01a\x1D!V[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[___``\x84\x86\x03\x12\x15a \x89W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a \xB1W__\xFD[\x825\x91Pa \xC1` \x84\x01a\x1DfV[\x90P\x92P\x92\x90PV[\x805\x80\x15\x15\x81\x14a\x1DvW__\xFD[__`@\x83\x85\x03\x12\x15a \xEAW__\xFD[a \xF3\x83a \xCAV[\x91Pa \xC1` \x84\x01a \xCAV[\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!^<#\x14a\x01*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x10vV[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\0W\x83\x82\x90_R` _ \x01\x80Ta\x03u\x90a\x16\xF4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xA1\x90a\x16\xF4V[\x80\x15a\x03\xECW\x80`\x1F\x10a\x03\xC3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xECV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xCFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03XV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xFAV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x05I\x90a\x16\xF4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05u\x90a\x16\xF4V[\x80\x15a\x05\xC0W\x80`\x1F\x10a\x05\x97Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05\xC0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05\xA3W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06WW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x06\x04W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05\x19V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\x06\xAF\x90a\x16\xF4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06\xDB\x90a\x16\xF4V[\x80\x15a\x07&W\x80`\x1F\x10a\x06\xFDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07&V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\tW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x06\x92V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x08%W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x07\xD2W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07]V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\t(W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x08\xD5W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x08`V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\t\x80\x90a\x16\xF4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\t\xAC\x90a\x16\xF4V[\x80\x15a\t\xF7W\x80`\x1F\x10a\t\xCEWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\t\xF7V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t\xDAW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\tcV[`\x08T_\x90`\xFF\x16\x15a\n\"WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\n\xB0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xD4\x91\x90a\x17EV[\x14\x15\x90P\x90V[`@Qs\xD6\x89\x01v\xE8\xD9\x12\x14*\xC4\x89\xE8\xB5\xD8\xD9?\x8D\xE7M`\x90s5\xB3\xF1\xBF\xE7\xCB\xE1\xE9Z=\xC2\xAD\x05N\xB6\xF0\xD4\xC8y\xB6\x90_\x90\x83\x90\x83\x90a\x0B\x19\x90a\x13OV[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x0BVW=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0B\xD0W__\xFD[PZ\xF1\x15\x80\x15a\x0B\xE2W=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0CeW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x89\x91\x90a\x17\\V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\r\x1DW__\xFD[PZ\xF1\x15\x80\x15a\r/W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\r\x8CW__\xFD[PZ\xF1\x15\x80\x15a\r\x9EW=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\x0EA\x93Pa\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\x17W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E;\x91\x90a\x17EV[_a\x12\xCCV[`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0E\xA4W__\xFD[PZ\xF1\x15\x80\x15a\x0E\xB6W=__>=_\xFD[PP`\x1FT`@Q\x7Fi2\x8D\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\x81Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01R`\x01`D\x83\x01R\x85\x16\x92Pci2\x8D\xEC\x91P`d\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0F?W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0Fc\x91\x90a\x17EV[P`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\x10\x06\x91a\x01\0\x90\x04s\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\xD8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xFC\x91\x90a\x17EV[c\x05\xF5\xE1\0a\x12\xCCV[PPPV[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\x11W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x118\x91\x90\x81\x01\x90a\x17\xAFV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x11V\x92\x91\x90a\x18cV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11rW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\x96\x91\x90a\x17EV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12\x0FW__\xFD[PZ\xF1\x15\x80\x15a\x12!W=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x12\xA1W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xC5\x91\x90a\x17\\V[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x135W__\xFD[PZ\xFA\x15\x80\x15a\x13GW=__>=_\xFD[PPPPPPV[a\r\x1E\x80a\x18\x85\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x13\xA9W\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\x13uV[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\xCAW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x14\xB0W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x14\x9A\x84\x86Qa\x13\xB4V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x14`V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x14\x08V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x15(W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x14\xE8V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\xCAW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x15~`@\x88\x01\x82a\x13\xB4V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x15\x99\x81\x83a\x14\xD6V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15XV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\xCAW`?\x19\x87\x86\x03\x01\x84Ra\x15\xF2\x85\x83Qa\x13\xB4V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\xD6V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\xCAW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x16u`@\x87\x01\x82a\x14\xD6V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16-V[\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\x16\xAEW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x16\xC6W__\xFD[\x845\x93Pa\x16\xD6` \x86\x01a\x16\x8BV[\x92Pa\x16\xE4`@\x86\x01a\x16\x8BV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x17\x08W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x17?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`\"`\x04R`$_\xFD[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17UW__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17lW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x17{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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x17\xBFW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17\xD5W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x17\xE5W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17\xFFWa\x17\xFFa\x17\x82V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x18/Wa\x18/a\x17\x82V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x18FW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x18u`@\x83\x01\x85a\x13\xB4V[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\x1E8\x03\x80a\r\x1E\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CHa\0\xD6_9_\x81\x81`S\x01R\x81\x81a\x01U\x01Ra\x02\x89\x01R_\x81\x81`\xA3\x01R\x81\x81a\x01\xC1\x01R\x81\x81a\x03(\x01Ra\x04b\x01Ra\x0CH_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x16\xF0\x11[\x14a\0NW\x80c%\xE2\xD6%\x14a\0\x9EW\x80cPcL\x0E\x14a\0\xC5W\x80c\x7F\x81O5\x14a\0\xDAW[__\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\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[a\0\xD8a\0\xD36`\x04a\t\xCEV[a\0\xEDV[\0[a\0\xD8a\0\xE86`\x04a\n\x90V[a\x01\x17V[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x14V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xBFV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x83V[`@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\x83\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B8V[`@Q\x7Fa{\xA07\0\0\0\0\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`$\x82\x01\x87\x90R\x85\x81\x16`D\x83\x01R_`d\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\x90ca{\xA07\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\xCCW__\xFD[PZ\xF1\x15\x80\x15a\x02\xDEW=__>=_\xFD[PP`@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\x86\x81\x16`\x04\x83\x01R_\x93P\x7F\0\0\0\0\0\0\0\0\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\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03nW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x92\x91\x90a\x0B8V[\x90P\x81\x81\x11a\x03\xE8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x03\xF3\x83\x83a\x0B|V[\x84Q\x90\x91P\x81\x10\x15a\x04GW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xDFV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05}\x90\x85\x90\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\x90`\x84\x01[`@\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~V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1B\x91\x90a\x0B8V[a\x06%\x91\x90a\x0B\x95V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05}\x90\x85\x90\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\x90`d\x01a\x05\x19V[_a\x06\xDF\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\x07t\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07oW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFD\x91\x90a\x0B\xA8V[a\x07oW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[PPPV[``a\x07\x82\x84\x84_\x85a\x07\x8CV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\x04W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08hW`@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\x03\xDFV[__\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\x08\x90\x91\x90a\x0B\xC7V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xCAW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xCFV[``\x91P[P\x91P\x91Pa\x08\xDF\x82\x82\x86a\x08\xEAV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xF9WP\x81a\x07\x85V[\x82Q\x15a\t\tW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xDF\x91\x90a\x0B\xDDV[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\tDW__\xFD[PV[\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\x97Wa\t\x97a\tGV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC6Wa\t\xC6a\tGV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE1W__\xFD[\x845a\t\xEC\x81a\t#V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x03\x81a\t#V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x1EW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n.W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nHWa\nHa\tGV[a\n[` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9DV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\noW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA4W__\xFD[\x855a\n\xAF\x81a\t#V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC6\x81a\t#V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF7W__\xFD[Pa\x0B\0a\ttV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B%W__\xFD[Pa\x0B.a\ttV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BHW__\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[\x81\x81\x03\x81\x81\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[_` \x82\x84\x03\x12\x15a\x0B\xB8W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x85W__\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\xFE\xA2dipfsX\"\x12 \x82\xCFY\x81d\x94k\x8Fq\x9CM\x82\xEF^\xF6\x0E=\xDAW\xBE\xC7=\xE3\xE8\x87\xB6ny\x0B\xF7WqdsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 \xF6}\x88\x98x7T\xF0\x89\xFBv\xDB[\"E\x9E\xF5\x8A\x13z\x05\xD7\xAD\xF2\xD2\xF8v\xFE\x84\xB0\xF0\xF5dsolcC\0\x08\x1C\x003", ); /// The runtime bytecode of the contract, as deployed on the network. /// /// ```text - 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 + ///0x608060405234801561000f575f5ffd5b50600436106100fb575f3560e01c8063b0464fdc11610093578063e20c9f7111610063578063e20c9f71146101bb578063f9ce0e5a146101c3578063fa7626d4146101d6578063fc0c546a146101e3575f5ffd5b8063b0464fdc1461018b578063b5508aa914610193578063ba414fa61461019b578063bab7137b146101b3575f5ffd5b80633f7286f4116100ce5780633f7286f41461014457806366d9a9a01461014c57806385226c8114610161578063916a17c614610176575f5ffd5b80630a9254e4146100ff5780631ed7831c146101095780632ade3880146101275780633e5e3c231461013c575b5f5ffd5b61010761022d565b005b61011161026a565b60405161011e919061135c565b60405180910390f35b61012f6102d7565b60405161011e91906113e2565b610111610420565b61011161048b565b6101546104f6565b60405161011e9190611532565b61016961066f565b60405161011e91906115b0565b61017e61073a565b60405161011e9190611607565b61017e61083d565b610169610940565b6101a3610a0b565b604051901515815260200161011e565b610107610adb565b61011161100b565b6101076101d13660046116b3565b611076565b601f546101a39060ff1681565b601f5461020890610100900473ffffffffffffffffffffffffffffffffffffffff1681565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200161011e565b610268625edcb2735a8e9774d67fe846c6f4311c073e2ac34b33646f73999999cf1046e68e36e1aa2e0e07105eddd1f08e6305f5e100611076565b565b606060168054806020026020016040519081016040528092919081815260200182805480156102cd57602002820191905f5260205f20905b815473ffffffffffffffffffffffffffffffffffffffff1681526001909101906020018083116102a2575b5050505050905090565b6060601e805480602002602001604051908101604052809291908181526020015f905b82821015610417575f848152602080822060408051808201825260028702909201805473ffffffffffffffffffffffffffffffffffffffff168352600181018054835181870281018701909452808452939591948681019491929084015b82821015610400578382905f5260205f20018054610375906116f4565b80601f01602080910402602001604051908101604052809291908181526020018280546103a1906116f4565b80156103ec5780601f106103c3576101008083540402835291602001916103ec565b820191905f5260205f20905b8154815290600101906020018083116103cf57829003601f168201915b505050505081526020019060010190610358565b5050505081525050815260200190600101906102fa565b50505050905090565b606060188054806020026020016040519081016040528092919081815260200182805480156102cd57602002820191905f5260205f2090815473ffffffffffffffffffffffffffffffffffffffff1681526001909101906020018083116102a2575050505050905090565b606060178054806020026020016040519081016040528092919081815260200182805480156102cd57602002820191905f5260205f2090815473ffffffffffffffffffffffffffffffffffffffff1681526001909101906020018083116102a2575050505050905090565b6060601b805480602002602001604051908101604052809291908181526020015f905b82821015610417578382905f5260205f2090600202016040518060400160405290815f82018054610549906116f4565b80601f0160208091040260200160405190810160405280929190818152602001828054610575906116f4565b80156105c05780601f10610597576101008083540402835291602001916105c0565b820191905f5260205f20905b8154815290600101906020018083116105a357829003601f168201915b505050505081526020016001820180548060200260200160405190810160405280929190818152602001828054801561065757602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916815260200190600401906020826003010492830192600103820291508084116106045790505b50505050508152505081526020019060010190610519565b6060601a805480602002602001604051908101604052809291908181526020015f905b82821015610417578382905f5260205f200180546106af906116f4565b80601f01602080910402602001604051908101604052809291908181526020018280546106db906116f4565b80156107265780601f106106fd57610100808354040283529160200191610726565b820191905f5260205f20905b81548152906001019060200180831161070957829003601f168201915b505050505081526020019060010190610692565b6060601d805480602002602001604051908101604052809291908181526020015f905b82821015610417575f84815260209081902060408051808201825260028602909201805473ffffffffffffffffffffffffffffffffffffffff16835260018101805483518187028101870190945280845293949193858301939283018282801561082557602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916815260200190600401906020826003010492830192600103820291508084116107d25790505b5050505050815250508152602001906001019061075d565b6060601c805480602002602001604051908101604052809291908181526020015f905b82821015610417575f84815260209081902060408051808201825260028602909201805473ffffffffffffffffffffffffffffffffffffffff16835260018101805483518187028101870190945280845293949193858301939283018282801561092857602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916815260200190600401906020826003010492830192600103820291508084116108d55790505b50505050508152505081526020019060010190610860565b60606019805480602002602001604051908101604052809291908181526020015f905b82821015610417578382905f5260205f20018054610980906116f4565b80601f01602080910402602001604051908101604052809291908181526020018280546109ac906116f4565b80156109f75780601f106109ce576101008083540402835291602001916109f7565b820191905f5260205f20905b8154815290600101906020018083116109da57829003601f168201915b505050505081526020019060010190610963565b6008545f9060ff1615610a22575060085460ff1690565b6040517f667f9d70000000000000000000000000000000000000000000000000000000008152737109709ecfa91a80626ff3989d68f67f5b1dd12d600482018190527f6661696c6564000000000000000000000000000000000000000000000000000060248301525f9163667f9d7090604401602060405180830381865afa158015610ab0573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610ad49190611745565b1415905090565b60405173d6890176e8d912142ac489e8b5d8d93f8de74d60907335b3f1bfe7cbe1e95a3dc2ad054eb6f0d4c879b6905f9083908390610b199061134f565b73ffffffffffffffffffffffffffffffffffffffff928316815291166020820152604001604051809103905ff080158015610b56573d5f5f3e3d5ffd5b506040517f06447d5600000000000000000000000000000000000000000000000000000000815273999999cf1046e68e36e1aa2e0e07105eddd1f08e6004820152909150737109709ecfa91a80626ff3989d68f67f5b1dd12d906306447d56906024015f604051808303815f87803b158015610bd0575f5ffd5b505af1158015610be2573d5f5f3e3d5ffd5b5050601f546040517f095ea7b300000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff85811660048301526305f5e1006024830152610100909204909116925063095ea7b391506044016020604051808303815f875af1158015610c65573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610c89919061175c565b50601f54604080516020810182525f815290517f7f814f3500000000000000000000000000000000000000000000000000000000815261010090920473ffffffffffffffffffffffffffffffffffffffff90811660048401526305f5e10060248401526001604484015290516064830152821690637f814f35906084015f604051808303815f87803b158015610d1d575f5ffd5b505af1158015610d2f573d5f5f3e3d5ffd5b50505050737109709ecfa91a80626ff3989d68f67f5b1dd12d73ffffffffffffffffffffffffffffffffffffffff166390c5013b6040518163ffffffff1660e01b81526004015f604051808303815f87803b158015610d8c575f5ffd5b505af1158015610d9e573d5f5f3e3d5ffd5b5050601f546040517f70a0823100000000000000000000000000000000000000000000000000000000815260016004820152610e41935061010090910473ffffffffffffffffffffffffffffffffffffffff1691506370a0823190602401602060405180830381865afa158015610e17573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610e3b9190611745565b5f6112cc565b6040517fca669fa700000000000000000000000000000000000000000000000000000000815260016004820152737109709ecfa91a80626ff3989d68f67f5b1dd12d9063ca669fa7906024015f604051808303815f87803b158015610ea4575f5ffd5b505af1158015610eb6573d5f5f3e3d5ffd5b5050601f546040517f69328dec00000000000000000000000000000000000000000000000000000000815261010090910473ffffffffffffffffffffffffffffffffffffffff90811660048301526305f5e100602483015260016044830152851692506369328dec91506064016020604051808303815f875af1158015610f3f573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610f639190611745565b50601f546040517f70a082310000000000000000000000000000000000000000000000000000000081526001600482015261100691610100900473ffffffffffffffffffffffffffffffffffffffff16906370a0823190602401602060405180830381865afa158015610fd8573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610ffc9190611745565b6305f5e1006112cc565b505050565b606060158054806020026020016040519081016040528092919081815260200182805480156102cd57602002820191905f5260205f2090815473ffffffffffffffffffffffffffffffffffffffff1681526001909101906020018083116102a2575050505050905090565b6040517ff877cb1900000000000000000000000000000000000000000000000000000000815260206004820152601760248201527f424f425f50524f445f5055424c49435f5250435f55524c0000000000000000006044820152737109709ecfa91a80626ff3989d68f67f5b1dd12d906371ee464d90829063f877cb19906064015f60405180830381865afa158015611111573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d908101601f1916820160405261113891908101906117af565b866040518363ffffffff1660e01b8152600401611156929190611863565b6020604051808303815f875af1158015611172573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906111969190611745565b506040517fca669fa700000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff84166004820152737109709ecfa91a80626ff3989d68f67f5b1dd12d9063ca669fa7906024015f604051808303815f87803b15801561120f575f5ffd5b505af1158015611221573d5f5f3e3d5ffd5b5050601f546040517fa9059cbb00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff868116600483015260248201869052610100909204909116925063a9059cbb91506044016020604051808303815f875af11580156112a1573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906112c5919061175c565b5050505050565b6040517f98296c540000000000000000000000000000000000000000000000000000000081526004810183905260248101829052737109709ecfa91a80626ff3989d68f67f5b1dd12d906398296c54906044015f6040518083038186803b158015611335575f5ffd5b505afa158015611347573d5f5f3e3d5ffd5b505050505050565b610d1e8061188583390190565b602080825282518282018190525f918401906040840190835b818110156113a957835173ffffffffffffffffffffffffffffffffffffffff16835260209384019390920191600101611375565b509095945050505050565b5f81518084528060208401602086015e5f602082860101526020601f19601f83011685010191505092915050565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b828110156114ca57603f198786030184528151805173ffffffffffffffffffffffffffffffffffffffff168652602090810151604082880181905281519088018190529101906060600582901b8801810191908801905f5b818110156114b0577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa08a850301835261149a8486516113b4565b6020958601959094509290920191600101611460565b509197505050602094850194929092019150600101611408565b50929695505050505050565b5f8151808452602084019350602083015f5b828110156115285781517fffffffff00000000000000000000000000000000000000000000000000000000168652602095860195909101906001016114e8565b5093949350505050565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b828110156114ca57603f19878603018452815180516040875261157e60408801826113b4565b905060208201519150868103602088015261159981836114d6565b965050506020938401939190910190600101611558565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b828110156114ca57603f198786030184526115f28583516113b4565b945060209384019391909101906001016115d6565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b828110156114ca57603f19878603018452815173ffffffffffffffffffffffffffffffffffffffff8151168652602081015190506040602087015261167560408701826114d6565b955050602093840193919091019060010161162d565b803573ffffffffffffffffffffffffffffffffffffffff811681146116ae575f5ffd5b919050565b5f5f5f5f608085870312156116c6575f5ffd5b843593506116d66020860161168b565b92506116e46040860161168b565b9396929550929360600135925050565b600181811c9082168061170857607f821691505b60208210810361173f577f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b50919050565b5f60208284031215611755575f5ffd5b5051919050565b5f6020828403121561176c575f5ffd5b8151801515811461177b575f5ffd5b9392505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b5f602082840312156117bf575f5ffd5b815167ffffffffffffffff8111156117d5575f5ffd5b8201601f810184136117e5575f5ffd5b805167ffffffffffffffff8111156117ff576117ff611782565b604051601f19603f601f19601f8501160116810181811067ffffffffffffffff8211171561182f5761182f611782565b604052818152828201602001861015611846575f5ffd5b8160208401602083015e5f91810160200191909152949350505050565b604081525f61187560408301856113b4565b9050826020830152939250505056fe60c060405234801561000f575f5ffd5b50604051610d1e380380610d1e83398101604081905261002e9161005c565b6001600160a01b039182166080521660a052610094565b6001600160a01b0381168114610059575f5ffd5b50565b5f5f6040838503121561006d575f5ffd5b825161007881610045565b602084015190925061008981610045565b809150509250929050565b60805160a051610c486100d65f395f8181605301528181610155015261028901525f818160a3015281816101c10152818161032801526104620152610c485ff3fe608060405234801561000f575f5ffd5b506004361061004a575f3560e01c806316f0115b1461004e57806325e2d6251461009e57806350634c0e146100c55780637f814f35146100da575b5f5ffd5b6100757f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200160405180910390f35b6100757f000000000000000000000000000000000000000000000000000000000000000081565b6100d86100d33660046109ce565b6100ed565b005b6100d86100e8366004610a90565b610117565b5f818060200190518101906101029190610b14565b905061011085858584610117565b5050505050565b61013973ffffffffffffffffffffffffffffffffffffffff85163330866104bf565b61017a73ffffffffffffffffffffffffffffffffffffffff85167f000000000000000000000000000000000000000000000000000000000000000085610583565b6040517f70a0823100000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff83811660048301525f917f0000000000000000000000000000000000000000000000000000000000000000909116906370a0823190602401602060405180830381865afa158015610208573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061022c9190610b38565b6040517f617ba03700000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff87811660048301526024820187905285811660448301525f60648301529192507f00000000000000000000000000000000000000000000000000000000000000009091169063617ba037906084015f604051808303815f87803b1580156102cc575f5ffd5b505af11580156102de573d5f5f3e3d5ffd5b50506040517f70a0823100000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff86811660048301525f93507f00000000000000000000000000000000000000000000000000000000000000001691506370a0823190602401602060405180830381865afa15801561036e573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103929190610b38565b90508181116103e85760405162461bcd60e51b815260206004820152601c60248201527f496e73756666696369656e7420737570706c792070726f76696465640000000060448201526064015b60405180910390fd5b5f6103f38383610b7c565b84519091508110156104475760405162461bcd60e51b815260206004820152601a60248201527f496e73756666696369656e74206f757470757420616d6f756e7400000000000060448201526064016103df565b6040805173ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000168152602081018390527f0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d910160405180910390a150505050505050565b60405173ffffffffffffffffffffffffffffffffffffffff8085166024830152831660448201526064810182905261057d9085907f23b872dd00000000000000000000000000000000000000000000000000000000906084015b60408051601f198184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff000000000000000000000000000000000000000000000000000000009093169290921790915261067e565b50505050565b6040517fdd62ed3e00000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff83811660248301525f91839186169063dd62ed3e90604401602060405180830381865afa1580156105f7573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061061b9190610b38565b6106259190610b95565b60405173ffffffffffffffffffffffffffffffffffffffff851660248201526044810182905290915061057d9085907f095ea7b30000000000000000000000000000000000000000000000000000000090606401610519565b5f6106df826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166107749092919063ffffffff16565b80519091501561076f57808060200190518101906106fd9190610ba8565b61076f5760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f7420737563636565640000000000000000000000000000000000000000000060648201526084016103df565b505050565b606061078284845f8561078c565b90505b9392505050565b6060824710156108045760405162461bcd60e51b815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c000000000000000000000000000000000000000000000000000060648201526084016103df565b73ffffffffffffffffffffffffffffffffffffffff85163b6108685760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e747261637400000060448201526064016103df565b5f5f8673ffffffffffffffffffffffffffffffffffffffff1685876040516108909190610bc7565b5f6040518083038185875af1925050503d805f81146108ca576040519150601f19603f3d011682016040523d82523d5f602084013e6108cf565b606091505b50915091506108df8282866108ea565b979650505050505050565b606083156108f9575081610785565b8251156109095782518084602001fd5b8160405162461bcd60e51b81526004016103df9190610bdd565b73ffffffffffffffffffffffffffffffffffffffff81168114610944575f5ffd5b50565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b6040516020810167ffffffffffffffff8111828210171561099757610997610947565b60405290565b604051601f8201601f1916810167ffffffffffffffff811182821017156109c6576109c6610947565b604052919050565b5f5f5f5f608085870312156109e1575f5ffd5b84356109ec81610923565b9350602085013592506040850135610a0381610923565b9150606085013567ffffffffffffffff811115610a1e575f5ffd5b8501601f81018713610a2e575f5ffd5b803567ffffffffffffffff811115610a4857610a48610947565b610a5b6020601f19601f8401160161099d565b818152886020838501011115610a6f575f5ffd5b816020840160208301375f6020838301015280935050505092959194509250565b5f5f5f5f8486036080811215610aa4575f5ffd5b8535610aaf81610923565b9450602086013593506040860135610ac681610923565b925060207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa082011215610af7575f5ffd5b50610b00610974565b606095909501358552509194909350909190565b5f6020828403128015610b25575f5ffd5b50610b2e610974565b9151825250919050565b5f60208284031215610b48575f5ffd5b5051919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b81810381811115610b8f57610b8f610b4f565b92915050565b80820180821115610b8f57610b8f610b4f565b5f60208284031215610bb8575f5ffd5b81518015158114610785575f5ffd5b5f82518060208501845e5f920191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f8301168401019150509291505056fea264697066735822122082cf598164946b8f719c4d82ef5ef60e3dda57bec73de3e887b66e790bf7577164736f6c634300081c0033a2646970667358221220f67d8898783754f089fb76db5b22459ef58a137a05d7adf2d2f876fe84b0f0f564736f6c634300081c0033 /// ``` #[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\x01/W_5`\xE0\x1C\x80cq\xF5\x13/\x11a\0\xADW\x80c\xB5P\x8A\xA9\x11a\0}W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x02OW\x80c\xFAv&\xD4\x14a\x02WW\x80c\xFA\xD0k\x8F\x14a\x02dW__\xFD[\x80c\xB5P\x8A\xA9\x14a\x02/W\x80c\xBAAO\xA6\x14a\x027W__\xFD[\x80cq\xF5\x13/\x14a\x01\xF5W\x80c\x85\"l\x81\x14a\x01\xFDW\x80c\x91j\x17\xC6\x14a\x02\x12W\x80c\xB0FO\xDC\x14a\x02'W__\xFD[\x80c>^<#\x11a\x01\x02W\x80cD\xBA\xDB\xB6\x11a\0\xE8W\x80cD\xBA\xDB\xB6\x14a\x01\xB6W\x80cP\xB9\xC5N\x14a\x01\xD6W\x80cf\xD9\xA9\xA0\x14a\x01\xE0W__\xFD[\x80c>^<#\x14a\x01\xA6W\x80c?r\x86\xF4\x14a\x01\xAEW__\xFD[\x80c\x08\x13\x85*\x14a\x013W\x80c\x1C\r\xA8\x1F\x14a\x01\\W\x80c\x1E\xD7\x83\x1C\x14a\x01|W\x80c*\xDE8\x80\x14a\x01\x91W[__\xFD[a\x01Fa\x01A6`\x04a\x16tV[a\x02wV[`@Qa\x01S\x91\x90a\x17)V[`@Q\x80\x91\x03\x90\xF3[a\x01oa\x01j6`\x04a\x16tV[a\x02\xC2V[`@Qa\x01S\x91\x90a\x17\x8CV[a\x01\x84a\x034V[`@Qa\x01S\x91\x90a\x17\x9EV[a\x01\x99a\x03\xA1V[`@Qa\x01S\x91\x90a\x18PV[a\x01\x84a\x04\xEAV[a\x01\x84a\x05UV[a\x01\xC9a\x01\xC46`\x04a\x16tV[a\x05\xC0V[`@Qa\x01S\x91\x90a\x18\xD4V[a\x01\xDEa\x06\x03V[\0[a\x01\xE8a\x06\xEFV[`@Qa\x01S\x91\x90a\x19gV[a\x01\xDEa\x08hV[a\x02\x05a\tRV[`@Qa\x01S\x91\x90a\x19\xE5V[a\x02\x1Aa\n\x1DV[`@Qa\x01S\x91\x90a\x19\xF7V[a\x02\x1Aa\x0B V[a\x02\x05a\x0C#V[a\x02?a\x0C\xEEV[`@Q\x90\x15\x15\x81R` \x01a\x01SV[a\x01\x84a\r\xBEV[`\x1FTa\x02?\x90`\xFF\x16\x81V[a\x01\xC9a\x02r6`\x04a\x16tV[a\x0E)V[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x0ElV[\x94\x93PPPPV[``_a\x02\xD0\x85\x85\x85a\x02wV[\x90P_[a\x02\xDE\x85\x85a\x1A\xA8V[\x81\x10\x15a\x03+W\x82\x82\x82\x81Q\x81\x10a\x02\xF8Wa\x02\xF8a\x1A\xBBV[` \x02` \x01\x01Q`@Q` \x01a\x03\x11\x92\x91\x90a\x1A\xFFV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x02\xD4V[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\xCAW\x83\x82\x90_R` _ \x01\x80Ta\x04?\x90a\x1B\x13V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x04k\x90a\x1B\x13V[\x80\x15a\x04\xB6W\x80`\x1F\x10a\x04\x8DWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x04\xB6V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x04\x99W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x04\"V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x03\xC4V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x0F\xCDV[a\x06\xED`\x1F`\x01\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\xB9\x85b\x1A`!T`\"`\x03\x81T\x81\x10a\x06[Wa\x06[a\x1A\xBBV[_\x91\x82R` \x90\x91 \x01T`@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\x81R`\x04\x81\x01\x92\x90\x92R`$\x82\x01R`\x01`D\x82\x01R`d\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xC4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xE8\x91\x90a\x1BdV[a\x11\x1BV[V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x07B\x90a\x1B\x13V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07n\x90a\x1B\x13V[\x80\x15a\x07\xB9W\x80`\x1F\x10a\x07\x90Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07\xB9V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\x9CW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x08PW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x07\xFDW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07\x12V[a\x06\xED`\x1F`\x01\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\xB9\x85b\x1A`!T`\"`\x03\x81T\x81\x10a\x08\xC0Wa\x08\xC0a\x1A\xBBV[_\x91\x82R` \x90\x91 \x01T`@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\x81R`\x04\x81\x01\x92\x90\x92R`$\x82\x01R`\x05`D\x82\x01R`d\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\t)W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\tM\x91\x90a\x1BdV[a\x11\x98V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x01\x80Ta\t\x92\x90a\x1B\x13V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\t\xBE\x90a\x1B\x13V[\x80\x15a\n\tW\x80`\x1F\x10a\t\xE0Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\tV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t\xECW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\tuV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0B\x08W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\n\xB5W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\n@V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\x0BW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0B\xB8W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0BCV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x01\x80Ta\x0Cc\x90a\x1B\x13V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C\x8F\x90a\x1B\x13V[\x80\x15a\x0C\xDAW\x80`\x1F\x10a\x0C\xB1Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C\xDAV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0C\xBDW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0CFV[`\x08T_\x90`\xFF\x16\x15a\r\x05WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\r\x93W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\xB7\x91\x90a\x1B\x8AV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x11\xEAV[``a\x0Ex\x84\x84a\x1A\xA8V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0E\x90Wa\x0E\x90a\x15\xEFV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0E\xC3W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x0E\xAEW\x90P[P\x90P\x83[\x83\x81\x10\x15a\x0F\xC4Wa\x0F\x96\x86a\x0E\xDD\x83a\x138V[\x85`@Q` \x01a\x0E\xF0\x93\x92\x91\x90a\x1B\xA1V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x0F\x0C\x90a\x1B\x13V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F8\x90a\x1B\x13V[\x80\x15a\x0F\x83W\x80`\x1F\x10a\x0FZWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F\x83V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0FfW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x14i\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x0F\xA1\x87\x84a\x1A\xA8V[\x81Q\x81\x10a\x0F\xB1Wa\x0F\xB1a\x1A\xBBV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x0E\xC8V[P\x94\x93PPPPV[``a\x0F\xD9\x84\x84a\x1A\xA8V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0F\xF1Wa\x0F\xF1a\x15\xEFV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x10\x1AW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x0F\xC4Wa\x10\xED\x86a\x104\x83a\x138V[\x85`@Q` \x01a\x10G\x93\x92\x91\x90a\x1B\xA1V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x10c\x90a\x1B\x13V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x10\x8F\x90a\x1B\x13V[\x80\x15a\x10\xDAW\x80`\x1F\x10a\x10\xB1Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x10\xDAV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x10\xBDW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x15\x08\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x10\xF8\x87\x84a\x1A\xA8V[\x81Q\x81\x10a\x11\x08Wa\x11\x08a\x1A\xBBV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x10\x1FV[`@Q\x7F\xA5\x98(\x85\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x81\x15\x15`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xA5\x98(\x85\x90`$\x01[_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x11\x7FW__\xFD[PZ\xFA\x15\x80\x15a\x11\x91W=__>=_\xFD[PPPPPV[`@Q\x7F\x0C\x9F\xD5\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\x81R\x81\x15\x15`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x0C\x9F\xD5\x81\x90`$\x01a\x11iV[``a\x11\xF6\x84\x84a\x1A\xA8V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\x0EWa\x12\x0Ea\x15\xEFV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x127W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x0F\xC4Wa\x13\n\x86a\x12Q\x83a\x138V[\x85`@Q` \x01a\x12d\x93\x92\x91\x90a\x1B\xA1V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x12\x80\x90a\x1B\x13V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x12\xAC\x90a\x1B\x13V[\x80\x15a\x12\xF7W\x80`\x1F\x10a\x12\xCEWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x12\xF7V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x12\xDAW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x15\x9B\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x13\x15\x87\x84a\x1A\xA8V[\x81Q\x81\x10a\x13%Wa\x13%a\x1A\xBBV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x12V[\x91Pa\x13\x9C\x90P`\n\x83a\x1C\xA2V[\x91Pa\x13}V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x13\xBDWa\x13\xBDa\x15\xEFV[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x13\xE7W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x02\xBAWa\x13\xFC`\x01\x83a\x1A\xA8V[\x91Pa\x14\t`\n\x86a\x1C\xB5V[a\x14\x14\x90`0a\x1C\xC8V[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x14)Wa\x14)a\x1A\xBBV[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x14b`\n\x86a\x1C\xA2V[\x94Pa\x13\xEBV[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a\x14\xBE\x90\x86\x90\x86\x90`\x04\x01a\x1C\xDBV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x14\xD8W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x14\xFF\x91\x90\x81\x01\x90a\x1D\x08V[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x15\\\x90\x86\x90\x86\x90`\x04\x01a\x1C\xDBV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x15wW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x14\xFF\x91\x90a\x1B\x8AV[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x15\\\x90\x86\x90\x86\x90`\x04\x01a\x1C\xDBV[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x16EWa\x16Ea\x15\xEFV[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x16fWa\x16fa\x15\xEFV[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x16\x86W__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\x9CW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x16\xACW__\xFD[\x805a\x16\xBFa\x16\xBA\x82a\x16MV[a\x16\x1CV[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x16\xD3W__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x17\x80W`?\x19\x87\x86\x03\x01\x84Ra\x17k\x85\x83Qa\x16\xFBV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x17OV[P\x92\x96\x95PPPPPPV[` \x81R_a\x14\xFF` \x83\x01\x84a\x16\xFBV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x17\xEBW\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\x17\xB7V[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x18DW`\x1F\x19\x85\x84\x03\x01\x88Ra\x18.\x83\x83Qa\x16\xFBV[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x18\x12V[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x17\x80W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x18\xBE`@\x87\x01\x82a\x17\xF6V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x18vV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x17\xEBW\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x18\xEDV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x19]W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x19\x1DV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x17\x80W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x19\xB3`@\x88\x01\x82a\x16\xFBV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x19\xCE\x81\x83a\x19\x0BV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x19\x8DV[` \x81R_a\x14\xFF` \x83\x01\x84a\x17\xF6V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x17\x80W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1Ae`@\x87\x01\x82a\x19\x0BV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1A\x1DV[\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\x15\x02Wa\x15\x02a\x1A{V[\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x02\xBAa\x1B\r\x83\x86a\x1A\xE8V[\x84a\x1A\xE8V[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1B'W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x1B^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`\"`\x04R`$_\xFD[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x1BtW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x1B\x83W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x1B\x9AW__\xFD[PQ\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\x81R_a\x1B\xD2`\x01\x83\x01\x86a\x1A\xE8V[\x7F[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x1C\x02`\x01\x82\x01\x86a\x1A\xE8V[\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\x81Ra\x1C4`\x02\x82\x01\x85a\x1A\xE8V[\x96\x95PPPPPPV[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x1CnWa\x1Cna\x1A{V[P`\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`\x12`\x04R`$_\xFD[_\x82a\x1C\xB0Wa\x1C\xB0a\x1CuV[P\x04\x90V[_\x82a\x1C\xC3Wa\x1C\xC3a\x1CuV[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a\x15\x02Wa\x15\x02a\x1A{V[`@\x81R_a\x1C\xED`@\x83\x01\x85a\x16\xFBV[\x82\x81\x03` \x84\x01Ra\x1C\xFF\x81\x85a\x16\xFBV[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x1D\x18W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D.W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x1D>W__\xFD[\x80Qa\x1DLa\x16\xBA\x82a\x16MV[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a\x1D`W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV\xFE\xA2dipfsX\"\x12 \x90Y\xC3\x96\x11M\xB9\x01'\xAC\xC5\xA1\x9D\xB2\xA3\xC0lf\xCD\xC7\x86zg\x12\x8B\x82\x84\xAE\xA6$,`dsolcC\0\x08\x1C\x003", + b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xFBW_5`\xE0\x1C\x80c\xB0FO\xDC\x11a\0\x93W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x01\xBBW\x80c\xF9\xCE\x0EZ\x14a\x01\xC3W\x80c\xFAv&\xD4\x14a\x01\xD6W\x80c\xFC\x0CTj\x14a\x01\xE3W__\xFD[\x80c\xB0FO\xDC\x14a\x01\x8BW\x80c\xB5P\x8A\xA9\x14a\x01\x93W\x80c\xBAAO\xA6\x14a\x01\x9BW\x80c\xBA\xB7\x13{\x14a\x01\xB3W__\xFD[\x80c?r\x86\xF4\x11a\0\xCEW\x80c?r\x86\xF4\x14a\x01DW\x80cf\xD9\xA9\xA0\x14a\x01LW\x80c\x85\"l\x81\x14a\x01aW\x80c\x91j\x17\xC6\x14a\x01vW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x1E\xD7\x83\x1C\x14a\x01\tW\x80c*\xDE8\x80\x14a\x01'W\x80c>^<#\x14a\x01*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x10vV[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\0W\x83\x82\x90_R` _ \x01\x80Ta\x03u\x90a\x16\xF4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xA1\x90a\x16\xF4V[\x80\x15a\x03\xECW\x80`\x1F\x10a\x03\xC3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xECV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xCFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03XV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xFAV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x05I\x90a\x16\xF4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05u\x90a\x16\xF4V[\x80\x15a\x05\xC0W\x80`\x1F\x10a\x05\x97Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05\xC0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05\xA3W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06WW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x06\x04W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05\x19V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\x06\xAF\x90a\x16\xF4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06\xDB\x90a\x16\xF4V[\x80\x15a\x07&W\x80`\x1F\x10a\x06\xFDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07&V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\tW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x06\x92V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x08%W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x07\xD2W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07]V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\t(W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x08\xD5W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x08`V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\t\x80\x90a\x16\xF4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\t\xAC\x90a\x16\xF4V[\x80\x15a\t\xF7W\x80`\x1F\x10a\t\xCEWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\t\xF7V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t\xDAW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\tcV[`\x08T_\x90`\xFF\x16\x15a\n\"WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\n\xB0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xD4\x91\x90a\x17EV[\x14\x15\x90P\x90V[`@Qs\xD6\x89\x01v\xE8\xD9\x12\x14*\xC4\x89\xE8\xB5\xD8\xD9?\x8D\xE7M`\x90s5\xB3\xF1\xBF\xE7\xCB\xE1\xE9Z=\xC2\xAD\x05N\xB6\xF0\xD4\xC8y\xB6\x90_\x90\x83\x90\x83\x90a\x0B\x19\x90a\x13OV[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x0BVW=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0B\xD0W__\xFD[PZ\xF1\x15\x80\x15a\x0B\xE2W=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0CeW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x89\x91\x90a\x17\\V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\r\x1DW__\xFD[PZ\xF1\x15\x80\x15a\r/W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\r\x8CW__\xFD[PZ\xF1\x15\x80\x15a\r\x9EW=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\x0EA\x93Pa\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\x17W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E;\x91\x90a\x17EV[_a\x12\xCCV[`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0E\xA4W__\xFD[PZ\xF1\x15\x80\x15a\x0E\xB6W=__>=_\xFD[PP`\x1FT`@Q\x7Fi2\x8D\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\x81Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01R`\x01`D\x83\x01R\x85\x16\x92Pci2\x8D\xEC\x91P`d\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0F?W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0Fc\x91\x90a\x17EV[P`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\x10\x06\x91a\x01\0\x90\x04s\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\xD8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xFC\x91\x90a\x17EV[c\x05\xF5\xE1\0a\x12\xCCV[PPPV[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\x11W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x118\x91\x90\x81\x01\x90a\x17\xAFV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x11V\x92\x91\x90a\x18cV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11rW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\x96\x91\x90a\x17EV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12\x0FW__\xFD[PZ\xF1\x15\x80\x15a\x12!W=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x12\xA1W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xC5\x91\x90a\x17\\V[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x135W__\xFD[PZ\xFA\x15\x80\x15a\x13GW=__>=_\xFD[PPPPPPV[a\r\x1E\x80a\x18\x85\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x13\xA9W\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\x13uV[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\xCAW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x14\xB0W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x14\x9A\x84\x86Qa\x13\xB4V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x14`V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x14\x08V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x15(W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x14\xE8V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\xCAW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x15~`@\x88\x01\x82a\x13\xB4V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x15\x99\x81\x83a\x14\xD6V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15XV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\xCAW`?\x19\x87\x86\x03\x01\x84Ra\x15\xF2\x85\x83Qa\x13\xB4V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\xD6V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\xCAW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x16u`@\x87\x01\x82a\x14\xD6V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16-V[\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\x16\xAEW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x16\xC6W__\xFD[\x845\x93Pa\x16\xD6` \x86\x01a\x16\x8BV[\x92Pa\x16\xE4`@\x86\x01a\x16\x8BV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x17\x08W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x17?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`\"`\x04R`$_\xFD[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17UW__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17lW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x17{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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x17\xBFW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17\xD5W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x17\xE5W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17\xFFWa\x17\xFFa\x17\x82V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x18/Wa\x18/a\x17\x82V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x18FW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x18u`@\x83\x01\x85a\x13\xB4V[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\x1E8\x03\x80a\r\x1E\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CHa\0\xD6_9_\x81\x81`S\x01R\x81\x81a\x01U\x01Ra\x02\x89\x01R_\x81\x81`\xA3\x01R\x81\x81a\x01\xC1\x01R\x81\x81a\x03(\x01Ra\x04b\x01Ra\x0CH_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x16\xF0\x11[\x14a\0NW\x80c%\xE2\xD6%\x14a\0\x9EW\x80cPcL\x0E\x14a\0\xC5W\x80c\x7F\x81O5\x14a\0\xDAW[__\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\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[a\0\xD8a\0\xD36`\x04a\t\xCEV[a\0\xEDV[\0[a\0\xD8a\0\xE86`\x04a\n\x90V[a\x01\x17V[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x14V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xBFV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x83V[`@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\x83\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B8V[`@Q\x7Fa{\xA07\0\0\0\0\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`$\x82\x01\x87\x90R\x85\x81\x16`D\x83\x01R_`d\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\x90ca{\xA07\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\xCCW__\xFD[PZ\xF1\x15\x80\x15a\x02\xDEW=__>=_\xFD[PP`@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\x86\x81\x16`\x04\x83\x01R_\x93P\x7F\0\0\0\0\0\0\0\0\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\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03nW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x92\x91\x90a\x0B8V[\x90P\x81\x81\x11a\x03\xE8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x03\xF3\x83\x83a\x0B|V[\x84Q\x90\x91P\x81\x10\x15a\x04GW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xDFV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05}\x90\x85\x90\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\x90`\x84\x01[`@\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~V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1B\x91\x90a\x0B8V[a\x06%\x91\x90a\x0B\x95V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05}\x90\x85\x90\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\x90`d\x01a\x05\x19V[_a\x06\xDF\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\x07t\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07oW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFD\x91\x90a\x0B\xA8V[a\x07oW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[PPPV[``a\x07\x82\x84\x84_\x85a\x07\x8CV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\x04W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08hW`@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\x03\xDFV[__\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\x08\x90\x91\x90a\x0B\xC7V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xCAW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xCFV[``\x91P[P\x91P\x91Pa\x08\xDF\x82\x82\x86a\x08\xEAV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xF9WP\x81a\x07\x85V[\x82Q\x15a\t\tW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xDF\x91\x90a\x0B\xDDV[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\tDW__\xFD[PV[\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\x97Wa\t\x97a\tGV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC6Wa\t\xC6a\tGV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE1W__\xFD[\x845a\t\xEC\x81a\t#V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x03\x81a\t#V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x1EW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n.W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nHWa\nHa\tGV[a\n[` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9DV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\noW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA4W__\xFD[\x855a\n\xAF\x81a\t#V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC6\x81a\t#V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF7W__\xFD[Pa\x0B\0a\ttV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B%W__\xFD[Pa\x0B.a\ttV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BHW__\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[\x81\x81\x03\x81\x81\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[_` \x82\x84\x03\x12\x15a\x0B\xB8W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x85W__\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\xFE\xA2dipfsX\"\x12 \x82\xCFY\x81d\x94k\x8Fq\x9CM\x82\xEF^\xF6\x0E=\xDAW\xBE\xC7=\xE3\xE8\x87\xB6ny\x0B\xF7WqdsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 \xF6}\x88\x98x7T\xF0\x89\xFBv\xDB[\"E\x9E\xF5\x8A\x13z\x05\xD7\xAD\xF2\xD2\xF8v\xFE\x84\xB0\xF0\xF5dsolcC\0\x08\x1C\x003", ); #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] @@ -4054,64 +3970,6 @@ event logs(bytes); } } }; - /**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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolConstructor for constructorCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - } - }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. @@ -5034,31 +4892,17 @@ function failed() external view returns (bool); }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getBlockHeights(string,uint256,uint256)` and selector `0xfad06b8f`. + /**Function with signature `setUp()` and selector `0x0a9254e4`. ```solidity -function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); +function setUp() external; ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getBlockHeightsCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getBlockHeights(string,uint256,uint256)`](getBlockHeightsCall) function. + pub struct setUpCall; + ///Container type for the return parameters of the [`setUp()`](setUpCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getBlockHeightsReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >, - } + pub struct setUpReturn {} #[allow( non_camel_case_types, non_snake_case, @@ -5069,17 +4913,9 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte use alloy::sol_types as alloy_sol_types; { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - 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::String, - 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( @@ -5093,34 +4929,24 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsCall) -> Self { - (value.chainName, value.from, value.to) + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpCall) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getBlockHeightsCall { + impl ::core::convert::From> for setUpCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } + Self } } } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); + type UnderlyingSolTuple<'a> = (); #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >, - ); + type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -5134,42 +4960,39 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsReturn) -> Self { - (value.elements,) + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpReturn) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> - for getBlockHeightsReturn { + impl ::core::convert::From> for setUpReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } + Self {} } } } + impl setUpReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } #[automatically_derived] - impl alloy_sol_types::SolCall for getBlockHeightsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); + impl alloy_sol_types::SolCall for setUpCall { + type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); + type Return = setUpReturn; + type ReturnTuple<'a> = (); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getBlockHeights(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [250u8, 208u8, 107u8, 143u8]; + const SIGNATURE: &'static str = "setUp()"; + const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -5178,35 +5001,18 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte } #[inline] fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) + () } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) + setUpReturn::_tokenize(ret) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) + .map(Into::into) } #[inline] fn abi_decode_returns_validate( @@ -5215,40 +5021,32 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) + .map(Into::into) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getDigestLes(string,uint256,uint256)` and selector `0x44badbb6`. + /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. ```solidity -function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); +function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getDigestLesCall { + pub struct simulateForkAndTransferCall { + #[allow(missing_docs)] + pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, + pub sender: alloy::sol_types::private::Address, #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, + pub receiver: alloy::sol_types::private::Address, #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, + pub amount: alloy::sol_types::private::primitives::aliases::U256, } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getDigestLes(string,uint256,uint256)`](getDigestLesCall) function. + ///Container type for the return parameters of the [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getDigestLesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >, - } + pub struct simulateForkAndTransferReturn {} #[allow( non_camel_case_types, non_snake_case, @@ -5260,14 +5058,16 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa { #[doc(hidden)] 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::Uint<256>, ); #[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::primitives::aliases::U256, ); #[cfg(test)] @@ -5283,36 +5083,31 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesCall) -> Self { - (value.chainName, value.from, value.to) + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferCall) -> Self { + (value.forkAtBlock, value.sender, value.receiver, value.amount) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getDigestLesCall { + impl ::core::convert::From> + for simulateForkAndTransferCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, + forkAtBlock: tuple.0, + sender: tuple.1, + receiver: tuple.2, + amount: tuple.3, } } } } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array< - alloy::sol_types::sol_data::FixedBytes<32>, - >, - ); + type UnderlyingSolTuple<'a> = (); #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >, - ); + type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -5326,228 +5121,48 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesReturn) -> Self { - (value.elements,) + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferReturn) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getDigestLesReturn { + impl ::core::convert::From> + for simulateForkAndTransferReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } + Self {} } } } - #[automatically_derived] - impl alloy_sol_types::SolCall for getDigestLesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array< - alloy::sol_types::sol_data::FixedBytes<32>, - >, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getDigestLes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [68u8, 186u8, 219u8, 182u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaderHexes(string,uint256,uint256)` and selector `0x0813852a`. -```solidity -function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaderHexes(string,uint256,uint256)`](getHeaderHexesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeaderHexesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getHeaderHexesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } + impl simulateForkAndTransferReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () } } #[automatically_derived] - impl alloy_sol_types::SolCall for getHeaderHexesCall { + impl alloy_sol_types::SolCall for simulateForkAndTransferCall { type Parameters<'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::Uint<256>, ); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Bytes, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); + type Return = simulateForkAndTransferReturn; + type ReturnTuple<'a> = (); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaderHexes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [8u8, 19u8, 133u8, 42u8]; + const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; + const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -5557,210 +5172,30 @@ function getHeaderHexes(string memory chainName, uint256 from, uint256 to) exter #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaders(string,uint256,uint256)` and selector `0x1c0da81f`. -```solidity -function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaders(string,uint256,uint256)`](getHeadersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersReturn { - #[allow(missing_docs)] - pub headers: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersReturn) -> Self { - (value.headers,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { headers: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getHeadersCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Bytes; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaders(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [28u8, 13u8, 168u8, 31u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, + > as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), + ::tokenize( + &self.sender, + ), + ::tokenize( + &self.receiver, ), as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), + > as alloy_sol_types::SolType>::tokenize(&self.amount), ) } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) + simulateForkAndTransferReturn::_tokenize(ret) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) + .map(Into::into) } #[inline] fn abi_decode_returns_validate( @@ -5769,10 +5204,7 @@ function getHeaders(string memory chainName, uint256 from, uint256 to) external as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) + .map(Into::into) } } }; @@ -6726,17 +6158,17 @@ function targetSenders() external view returns (address[] memory targetedSenders }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testAncestorFound()` and selector `0x71f5132f`. + /**Function with signature `testAvalonWBTCStrategy()` and selector `0xbab7137b`. ```solidity -function testAncestorFound() external view; +function testAvalonWBTCStrategy() external; ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testAncestorFoundCall; - ///Container type for the return parameters of the [`testAncestorFound()`](testAncestorFoundCall) function. + pub struct testAvalonWBTCStrategyCall; + ///Container type for the return parameters of the [`testAvalonWBTCStrategy()`](testAvalonWBTCStrategyCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testAncestorFoundReturn {} + pub struct testAvalonWBTCStrategyReturn {} #[allow( non_camel_case_types, non_snake_case, @@ -6763,16 +6195,16 @@ function testAncestorFound() external view; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: testAncestorFoundCall) -> Self { + fn from(value: testAvalonWBTCStrategyCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for testAncestorFoundCall { + for testAvalonWBTCStrategyCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -6796,41 +6228,43 @@ function testAncestorFound() external view; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: testAncestorFoundReturn) -> Self { + fn from(value: testAvalonWBTCStrategyReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for testAncestorFoundReturn { + for testAvalonWBTCStrategyReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } } } - impl testAncestorFoundReturn { + impl testAvalonWBTCStrategyReturn { fn _tokenize( &self, - ) -> ::ReturnToken<'_> { + ) -> ::ReturnToken< + '_, + > { () } } #[automatically_derived] - impl alloy_sol_types::SolCall for testAncestorFoundCall { + impl alloy_sol_types::SolCall for testAvalonWBTCStrategyCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testAncestorFoundReturn; + type Return = testAvalonWBTCStrategyReturn; type ReturnTuple<'a> = (); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testAncestorFound()"; - const SELECTOR: [u8; 4] = [113u8, 245u8, 19u8, 47u8]; + const SIGNATURE: &'static str = "testAvalonWBTCStrategy()"; + const SELECTOR: [u8; 4] = [186u8, 183u8, 19u8, 123u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -6843,7 +6277,7 @@ function testAncestorFound() external view; } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testAncestorFoundReturn::_tokenize(ret) + testAvalonWBTCStrategyReturn::_tokenize(ret) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { @@ -6865,17 +6299,22 @@ function testAncestorFound() external view; }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testExceedSearchLimit()` and selector `0x50b9c54e`. + /**Function with signature `token()` and selector `0xfc0c546a`. ```solidity -function testExceedSearchLimit() external view; +function token() external view returns (address); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testExceedSearchLimitCall; - ///Container type for the return parameters of the [`testExceedSearchLimit()`](testExceedSearchLimitCall) function. + pub struct tokenCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`token()`](tokenCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testExceedSearchLimitReturn {} + pub struct tokenReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } #[allow( non_camel_case_types, non_snake_case, @@ -6902,16 +6341,14 @@ function testExceedSearchLimit() external view; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testExceedSearchLimitCall) -> Self { + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> - for testExceedSearchLimitCall { + impl ::core::convert::From> for tokenCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -6919,9 +6356,9 @@ function testExceedSearchLimit() external view; } { #[doc(hidden)] - 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( @@ -6935,43 +6372,32 @@ function testExceedSearchLimit() external view; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testExceedSearchLimitReturn) -> Self { - () + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenReturn) -> Self { + (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> - for testExceedSearchLimitReturn { + impl ::core::convert::From> for tokenReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} + Self { _0: tuple.0 } } } } - impl testExceedSearchLimitReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } #[automatically_derived] - impl alloy_sol_types::SolCall for testExceedSearchLimitCall { + impl alloy_sol_types::SolCall for tokenCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testExceedSearchLimitReturn; - type ReturnTuple<'a> = (); + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testExceedSearchLimit()"; - const SELECTOR: [u8; 4] = [80u8, 185u8, 197u8, 78u8]; + const SIGNATURE: &'static str = "token()"; + const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -6984,14 +6410,21 @@ function testExceedSearchLimit() external view; } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testExceedSearchLimitReturn::_tokenize(ret) + ( + ::tokenize( + ret, + ), + ) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) } #[inline] fn abi_decode_returns_validate( @@ -7000,14 +6433,17 @@ function testExceedSearchLimit() external view; as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) } } }; - ///Container for all the [`FullRelayIsAncestorTest`](self) function calls. + ///Container for all the [`AvalonWBTCLendingStrategyForked`](self) function calls. #[derive(serde::Serialize, serde::Deserialize)] #[derive()] - pub enum FullRelayIsAncestorTestCalls { + pub enum AvalonWBTCLendingStrategyForkedCalls { #[allow(missing_docs)] IS_TEST(IS_TESTCall), #[allow(missing_docs)] @@ -7021,13 +6457,9 @@ function testExceedSearchLimit() external view; #[allow(missing_docs)] failed(failedCall), #[allow(missing_docs)] - getBlockHeights(getBlockHeightsCall), + setUp(setUpCall), #[allow(missing_docs)] - getDigestLes(getDigestLesCall), - #[allow(missing_docs)] - getHeaderHexes(getHeaderHexesCall), - #[allow(missing_docs)] - getHeaders(getHeadersCall), + simulateForkAndTransfer(simulateForkAndTransferCall), #[allow(missing_docs)] targetArtifactSelectors(targetArtifactSelectorsCall), #[allow(missing_docs)] @@ -7041,12 +6473,12 @@ function testExceedSearchLimit() external view; #[allow(missing_docs)] targetSenders(targetSendersCall), #[allow(missing_docs)] - testAncestorFound(testAncestorFoundCall), + testAvalonWBTCStrategy(testAvalonWBTCStrategyCall), #[allow(missing_docs)] - testExceedSearchLimit(testExceedSearchLimitCall), + token(tokenCall), } #[automatically_derived] - impl FullRelayIsAncestorTestCalls { + impl AvalonWBTCLendingStrategyForkedCalls { /// All the selectors of this enum. /// /// Note that the selectors might not be in the same order as the variants. @@ -7054,31 +6486,29 @@ function testExceedSearchLimit() external view; /// /// Prefer using `SolInterface` methods instead. pub const SELECTORS: &'static [[u8; 4usize]] = &[ - [8u8, 19u8, 133u8, 42u8], - [28u8, 13u8, 168u8, 31u8], + [10u8, 146u8, 84u8, 228u8], [30u8, 215u8, 131u8, 28u8], [42u8, 222u8, 56u8, 128u8], [62u8, 94u8, 60u8, 35u8], [63u8, 114u8, 134u8, 244u8], - [68u8, 186u8, 219u8, 182u8], - [80u8, 185u8, 197u8, 78u8], [102u8, 217u8, 169u8, 160u8], - [113u8, 245u8, 19u8, 47u8], [133u8, 34u8, 108u8, 129u8], [145u8, 106u8, 23u8, 198u8], [176u8, 70u8, 79u8, 220u8], [181u8, 80u8, 138u8, 169u8], [186u8, 65u8, 79u8, 166u8], + [186u8, 183u8, 19u8, 123u8], [226u8, 12u8, 159u8, 113u8], + [249u8, 206u8, 14u8, 90u8], [250u8, 118u8, 38u8, 212u8], - [250u8, 208u8, 107u8, 143u8], + [252u8, 12u8, 84u8, 106u8], ]; } #[automatically_derived] - impl alloy_sol_types::SolInterface for FullRelayIsAncestorTestCalls { - const NAME: &'static str = "FullRelayIsAncestorTestCalls"; + impl alloy_sol_types::SolInterface for AvalonWBTCLendingStrategyForkedCalls { + const NAME: &'static str = "AvalonWBTCLendingStrategyForkedCalls"; const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 18usize; + const COUNT: usize = 16usize; #[inline] fn selector(&self) -> [u8; 4] { match self { @@ -7096,17 +6526,9 @@ function testExceedSearchLimit() external view; ::SELECTOR } Self::failed(_) => ::SELECTOR, - Self::getBlockHeights(_) => { - ::SELECTOR - } - Self::getDigestLes(_) => { - ::SELECTOR - } - Self::getHeaderHexes(_) => { - ::SELECTOR - } - Self::getHeaders(_) => { - ::SELECTOR + Self::setUp(_) => ::SELECTOR, + Self::simulateForkAndTransfer(_) => { + ::SELECTOR } Self::targetArtifactSelectors(_) => { ::SELECTOR @@ -7126,12 +6548,10 @@ function testExceedSearchLimit() external view; Self::targetSenders(_) => { ::SELECTOR } - Self::testAncestorFound(_) => { - ::SELECTOR - } - Self::testExceedSearchLimit(_) => { - ::SELECTOR + Self::testAvalonWBTCStrategy(_) => { + ::SELECTOR } + Self::token(_) => ::SELECTOR, } } #[inline] @@ -7150,200 +6570,180 @@ function testExceedSearchLimit() external view; ) -> alloy_sol_types::Result { static DECODE_SHIMS: &[fn( &[u8], - ) -> alloy_sol_types::Result] = &[ + ) -> alloy_sol_types::Result] = &[ { - fn getHeaderHexes( + fn setUp( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayIsAncestorTestCalls::getHeaderHexes) - } - getHeaderHexes - }, - { - fn getHeaders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayIsAncestorTestCalls::getHeaders) + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(AvalonWBTCLendingStrategyForkedCalls::setUp) } - getHeaders + setUp }, { fn excludeSenders( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayIsAncestorTestCalls::excludeSenders) + .map(AvalonWBTCLendingStrategyForkedCalls::excludeSenders) } excludeSenders }, { fn targetInterfaces( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayIsAncestorTestCalls::targetInterfaces) + .map(AvalonWBTCLendingStrategyForkedCalls::targetInterfaces) } targetInterfaces }, { fn targetSenders( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayIsAncestorTestCalls::targetSenders) + .map(AvalonWBTCLendingStrategyForkedCalls::targetSenders) } targetSenders }, { fn targetContracts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayIsAncestorTestCalls::targetContracts) + .map(AvalonWBTCLendingStrategyForkedCalls::targetContracts) } targetContracts }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayIsAncestorTestCalls::getDigestLes) - } - getDigestLes - }, - { - fn testExceedSearchLimit( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayIsAncestorTestCalls::testExceedSearchLimit) - } - testExceedSearchLimit - }, { fn targetArtifactSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayIsAncestorTestCalls::targetArtifactSelectors) - } - targetArtifactSelectors - }, - { - fn testAncestorFound( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, + .map( + AvalonWBTCLendingStrategyForkedCalls::targetArtifactSelectors, ) - .map(FullRelayIsAncestorTestCalls::testAncestorFound) } - testAncestorFound + targetArtifactSelectors }, { fn targetArtifacts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayIsAncestorTestCalls::targetArtifacts) + .map(AvalonWBTCLendingStrategyForkedCalls::targetArtifacts) } targetArtifacts }, { fn targetSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayIsAncestorTestCalls::targetSelectors) + .map(AvalonWBTCLendingStrategyForkedCalls::targetSelectors) } targetSelectors }, { fn excludeSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayIsAncestorTestCalls::excludeSelectors) + .map(AvalonWBTCLendingStrategyForkedCalls::excludeSelectors) } excludeSelectors }, { fn excludeArtifacts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayIsAncestorTestCalls::excludeArtifacts) + .map(AvalonWBTCLendingStrategyForkedCalls::excludeArtifacts) } excludeArtifacts }, { fn failed( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw(data) - .map(FullRelayIsAncestorTestCalls::failed) + .map(AvalonWBTCLendingStrategyForkedCalls::failed) } failed }, + { + fn testAvalonWBTCStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + AvalonWBTCLendingStrategyForkedCalls::testAvalonWBTCStrategy, + ) + } + testAvalonWBTCStrategy + }, { fn excludeContracts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayIsAncestorTestCalls::excludeContracts) + .map(AvalonWBTCLendingStrategyForkedCalls::excludeContracts) } excludeContracts }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + AvalonWBTCLendingStrategyForkedCalls::simulateForkAndTransfer, + ) + } + simulateForkAndTransfer + }, { fn IS_TEST( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw(data) - .map(FullRelayIsAncestorTestCalls::IS_TEST) + .map(AvalonWBTCLendingStrategyForkedCalls::IS_TEST) } IS_TEST }, { - fn getBlockHeights( + fn token( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayIsAncestorTestCalls::getBlockHeights) + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(AvalonWBTCLendingStrategyForkedCalls::token) } - getBlockHeights + token }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { @@ -7364,204 +6764,188 @@ function testExceedSearchLimit() external view; ) -> alloy_sol_types::Result { static DECODE_VALIDATE_SHIMS: &[fn( &[u8], - ) -> alloy_sol_types::Result] = &[ + ) -> alloy_sol_types::Result] = &[ { - fn getHeaderHexes( + fn setUp( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( data, ) - .map(FullRelayIsAncestorTestCalls::getHeaderHexes) + .map(AvalonWBTCLendingStrategyForkedCalls::setUp) } - getHeaderHexes - }, - { - fn getHeaders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayIsAncestorTestCalls::getHeaders) - } - getHeaders + setUp }, { fn excludeSenders( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayIsAncestorTestCalls::excludeSenders) + .map(AvalonWBTCLendingStrategyForkedCalls::excludeSenders) } excludeSenders }, { fn targetInterfaces( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayIsAncestorTestCalls::targetInterfaces) + .map(AvalonWBTCLendingStrategyForkedCalls::targetInterfaces) } targetInterfaces }, { fn targetSenders( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayIsAncestorTestCalls::targetSenders) + .map(AvalonWBTCLendingStrategyForkedCalls::targetSenders) } targetSenders }, { fn targetContracts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayIsAncestorTestCalls::targetContracts) + .map(AvalonWBTCLendingStrategyForkedCalls::targetContracts) } targetContracts }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayIsAncestorTestCalls::getDigestLes) - } - getDigestLes - }, - { - fn testExceedSearchLimit( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayIsAncestorTestCalls::testExceedSearchLimit) - } - testExceedSearchLimit - }, { fn targetArtifactSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayIsAncestorTestCalls::targetArtifactSelectors) - } - targetArtifactSelectors - }, - { - fn testAncestorFound( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, + .map( + AvalonWBTCLendingStrategyForkedCalls::targetArtifactSelectors, ) - .map(FullRelayIsAncestorTestCalls::testAncestorFound) } - testAncestorFound + targetArtifactSelectors }, { fn targetArtifacts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayIsAncestorTestCalls::targetArtifacts) + .map(AvalonWBTCLendingStrategyForkedCalls::targetArtifacts) } targetArtifacts }, { fn targetSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayIsAncestorTestCalls::targetSelectors) + .map(AvalonWBTCLendingStrategyForkedCalls::targetSelectors) } targetSelectors }, { fn excludeSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayIsAncestorTestCalls::excludeSelectors) + .map(AvalonWBTCLendingStrategyForkedCalls::excludeSelectors) } excludeSelectors }, { fn excludeArtifacts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayIsAncestorTestCalls::excludeArtifacts) + .map(AvalonWBTCLendingStrategyForkedCalls::excludeArtifacts) } excludeArtifacts }, { fn failed( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayIsAncestorTestCalls::failed) + .map(AvalonWBTCLendingStrategyForkedCalls::failed) } failed }, + { + fn testAvalonWBTCStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + AvalonWBTCLendingStrategyForkedCalls::testAvalonWBTCStrategy, + ) + } + testAvalonWBTCStrategy + }, { fn excludeContracts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayIsAncestorTestCalls::excludeContracts) + .map(AvalonWBTCLendingStrategyForkedCalls::excludeContracts) } excludeContracts }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + AvalonWBTCLendingStrategyForkedCalls::simulateForkAndTransfer, + ) + } + simulateForkAndTransfer + }, { fn IS_TEST( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayIsAncestorTestCalls::IS_TEST) + .map(AvalonWBTCLendingStrategyForkedCalls::IS_TEST) } IS_TEST }, { - fn getBlockHeights( + fn token( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( data, ) - .map(FullRelayIsAncestorTestCalls::getBlockHeights) + .map(AvalonWBTCLendingStrategyForkedCalls::token) } - getBlockHeights + token }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { @@ -7603,24 +6987,14 @@ function testExceedSearchLimit() external view; Self::failed(inner) => { ::abi_encoded_size(inner) } - Self::getBlockHeights(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getDigestLes(inner) => { - ::abi_encoded_size( - inner, - ) + Self::setUp(inner) => { + ::abi_encoded_size(inner) } - Self::getHeaderHexes(inner) => { - ::abi_encoded_size( + Self::simulateForkAndTransfer(inner) => { + ::abi_encoded_size( inner, ) } - Self::getHeaders(inner) => { - ::abi_encoded_size(inner) - } Self::targetArtifactSelectors(inner) => { ::abi_encoded_size( inner, @@ -7651,15 +7025,13 @@ function testExceedSearchLimit() external view; inner, ) } - Self::testAncestorFound(inner) => { - ::abi_encoded_size( + Self::testAvalonWBTCStrategy(inner) => { + ::abi_encoded_size( inner, ) } - Self::testExceedSearchLimit(inner) => { - ::abi_encoded_size( - inner, - ) + Self::token(inner) => { + ::abi_encoded_size(inner) } } } @@ -7696,26 +7068,11 @@ function testExceedSearchLimit() external view; Self::failed(inner) => { ::abi_encode_raw(inner, out) } - Self::getBlockHeights(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getDigestLes(inner) => { - ::abi_encode_raw( - inner, - out, - ) + Self::setUp(inner) => { + ::abi_encode_raw(inner, out) } - Self::getHeaderHexes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaders(inner) => { - ::abi_encode_raw( + Self::simulateForkAndTransfer(inner) => { + ::abi_encode_raw( inner, out, ) @@ -7756,25 +7113,22 @@ function testExceedSearchLimit() external view; out, ) } - Self::testAncestorFound(inner) => { - ::abi_encode_raw( + Self::testAvalonWBTCStrategy(inner) => { + ::abi_encode_raw( inner, out, ) } - Self::testExceedSearchLimit(inner) => { - ::abi_encode_raw( - inner, - out, - ) + Self::token(inner) => { + ::abi_encode_raw(inner, out) } } } } - ///Container for all the [`FullRelayIsAncestorTest`](self) events. + ///Container for all the [`AvalonWBTCLendingStrategyForked`](self) events. #[derive(serde::Serialize, serde::Deserialize)] #[derive()] - pub enum FullRelayIsAncestorTestEvents { + pub enum AvalonWBTCLendingStrategyForkedEvents { #[allow(missing_docs)] log(log), #[allow(missing_docs)] @@ -7821,7 +7175,7 @@ function testExceedSearchLimit() external view; logs(logs), } #[automatically_derived] - impl FullRelayIsAncestorTestEvents { + impl AvalonWBTCLendingStrategyForkedEvents { /// All the selectors of this enum. /// /// Note that the selectors might not be in the same order as the variants. @@ -7942,8 +7296,8 @@ function testExceedSearchLimit() external view; ]; } #[automatically_derived] - impl alloy_sol_types::SolEventInterface for FullRelayIsAncestorTestEvents { - const NAME: &'static str = "FullRelayIsAncestorTestEvents"; + impl alloy_sol_types::SolEventInterface for AvalonWBTCLendingStrategyForkedEvents { + const NAME: &'static str = "AvalonWBTCLendingStrategyForkedEvents"; const COUNT: usize = 22usize; fn decode_raw_log( topics: &[alloy_sol_types::Word], @@ -8121,7 +7475,8 @@ function testExceedSearchLimit() external view; } } #[automatically_derived] - impl alloy_sol_types::private::IntoLogData for FullRelayIsAncestorTestEvents { + impl alloy_sol_types::private::IntoLogData + for AvalonWBTCLendingStrategyForkedEvents { fn to_log_data(&self) -> alloy_sol_types::private::LogData { match self { Self::log(inner) => { @@ -8264,9 +7619,9 @@ function testExceedSearchLimit() external view; } } use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`FullRelayIsAncestorTest`](self) contract instance. + /**Creates a new wrapper around an on-chain [`AvalonWBTCLendingStrategyForked`](self) contract instance. -See the [wrapper's documentation](`FullRelayIsAncestorTestInstance`) for more details.*/ +See the [wrapper's documentation](`AvalonWBTCLendingStrategyForkedInstance`) for more details.*/ #[inline] pub const fn new< P: alloy_contract::private::Provider, @@ -8274,8 +7629,8 @@ See the [wrapper's documentation](`FullRelayIsAncestorTestInstance`) for more de >( address: alloy_sol_types::private::Address, provider: P, - ) -> FullRelayIsAncestorTestInstance { - FullRelayIsAncestorTestInstance::::new(address, provider) + ) -> AvalonWBTCLendingStrategyForkedInstance { + AvalonWBTCLendingStrategyForkedInstance::::new(address, provider) } /**Deploys this contract using the given `provider` and constructor arguments, if any. @@ -8289,9 +7644,9 @@ For more fine-grained control over the deployment process, use [`deploy_builder` >( provider: P, ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, + Output = alloy_contract::Result>, > { - FullRelayIsAncestorTestInstance::::deploy(provider) + AvalonWBTCLendingStrategyForkedInstance::::deploy(provider) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` and constructor arguments, if any. @@ -8303,12 +7658,12 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ P: alloy_contract::private::Provider, N: alloy_contract::private::Network, >(provider: P) -> alloy_contract::RawCallBuilder { - FullRelayIsAncestorTestInstance::::deploy_builder(provider) + AvalonWBTCLendingStrategyForkedInstance::::deploy_builder(provider) } - /**A [`FullRelayIsAncestorTest`](self) instance. + /**A [`AvalonWBTCLendingStrategyForked`](self) instance. Contains type-safe methods for interacting with an on-chain instance of the -[`FullRelayIsAncestorTest`](self) contract located at a given `address`, using a given +[`AvalonWBTCLendingStrategyForked`](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!) @@ -8317,7 +7672,7 @@ 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 FullRelayIsAncestorTestInstance< + pub struct AvalonWBTCLendingStrategyForkedInstance< P, N = alloy_contract::private::Ethereum, > { @@ -8326,10 +7681,10 @@ See the [module-level documentation](self) for all the available methods.*/ _network: ::core::marker::PhantomData, } #[automatically_derived] - impl ::core::fmt::Debug for FullRelayIsAncestorTestInstance { + impl ::core::fmt::Debug for AvalonWBTCLendingStrategyForkedInstance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("FullRelayIsAncestorTestInstance") + f.debug_tuple("AvalonWBTCLendingStrategyForkedInstance") .field(&self.address) .finish() } @@ -8339,10 +7694,10 @@ See the [module-level documentation](self) for all the available methods.*/ impl< P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - > FullRelayIsAncestorTestInstance { - /**Creates a new wrapper around an on-chain [`FullRelayIsAncestorTest`](self) contract instance. + > AvalonWBTCLendingStrategyForkedInstance { + /**Creates a new wrapper around an on-chain [`AvalonWBTCLendingStrategyForked`](self) contract instance. -See the [wrapper's documentation](`FullRelayIsAncestorTestInstance`) for more details.*/ +See the [wrapper's documentation](`AvalonWBTCLendingStrategyForkedInstance`) for more details.*/ #[inline] pub const fn new( address: alloy_sol_types::private::Address, @@ -8362,7 +7717,7 @@ For more fine-grained control over the deployment process, use [`deploy_builder` #[inline] pub async fn deploy( provider: P, - ) -> alloy_contract::Result> { + ) -> alloy_contract::Result> { let call_builder = Self::deploy_builder(provider); let contract_address = call_builder.deploy().await?; Ok(Self::new(contract_address, call_builder.provider)) @@ -8400,11 +7755,13 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ &self.provider } } - impl FullRelayIsAncestorTestInstance<&P, N> { + impl AvalonWBTCLendingStrategyForkedInstance<&P, N> { /// Clones the provider and returns a new instance with the cloned provider. #[inline] - pub fn with_cloned_provider(self) -> FullRelayIsAncestorTestInstance { - FullRelayIsAncestorTestInstance { + pub fn with_cloned_provider( + self, + ) -> AvalonWBTCLendingStrategyForkedInstance { + AvalonWBTCLendingStrategyForkedInstance { address: self.address, provider: ::core::clone::Clone::clone(&self.provider), _network: ::core::marker::PhantomData, @@ -8416,7 +7773,7 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ impl< P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - > FullRelayIsAncestorTestInstance { + > AvalonWBTCLendingStrategyForkedInstance { /// 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 @@ -8459,63 +7816,24 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { self.call_builder(&failedCall) } - ///Creates a new call builder for the [`getBlockHeights`] function. - pub fn getBlockHeights( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getBlockHeightsCall, N> { - self.call_builder( - &getBlockHeightsCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getDigestLes`] function. - pub fn getDigestLes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getDigestLesCall, N> { - self.call_builder( - &getDigestLesCall { - chainName, - from, - to, - }, - ) + ///Creates a new call builder for the [`setUp`] function. + pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { + self.call_builder(&setUpCall) } - ///Creates a new call builder for the [`getHeaderHexes`] function. - pub fn getHeaderHexes( + ///Creates a new call builder for the [`simulateForkAndTransfer`] function. + pub fn simulateForkAndTransfer( &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeaderHexesCall, N> { + forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + sender: alloy::sol_types::private::Address, + receiver: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { self.call_builder( - &getHeaderHexesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaders`] function. - pub fn getHeaders( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeadersCall, N> { - self.call_builder( - &getHeadersCall { - chainName, - from, - to, + &simulateForkAndTransferCall { + forkAtBlock, + sender, + receiver, + amount, }, ) } @@ -8555,17 +7873,15 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { self.call_builder(&targetSendersCall) } - ///Creates a new call builder for the [`testAncestorFound`] function. - pub fn testAncestorFound( + ///Creates a new call builder for the [`testAvalonWBTCStrategy`] function. + pub fn testAvalonWBTCStrategy( &self, - ) -> alloy_contract::SolCallBuilder<&P, testAncestorFoundCall, N> { - self.call_builder(&testAncestorFoundCall) + ) -> alloy_contract::SolCallBuilder<&P, testAvalonWBTCStrategyCall, N> { + self.call_builder(&testAvalonWBTCStrategyCall) } - ///Creates a new call builder for the [`testExceedSearchLimit`] function. - pub fn testExceedSearchLimit( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testExceedSearchLimitCall, N> { - self.call_builder(&testExceedSearchLimitCall) + ///Creates a new call builder for the [`token`] function. + pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { + self.call_builder(&tokenCall) } } /// Event filters. @@ -8573,7 +7889,7 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ impl< P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - > FullRelayIsAncestorTestInstance { + > AvalonWBTCLendingStrategyForkedInstance { /// 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. diff --git a/crates/bindings/src/avalon_wbtc_lst_strategy_forked.rs b/crates/bindings/src/avalon_wbtc_lst_strategy_forked.rs new file mode 100644 index 000000000..640154528 --- /dev/null +++ b/crates/bindings/src/avalon_wbtc_lst_strategy_forked.rs @@ -0,0 +1,8004 @@ +///Module containing a contract's types and functions. +/** + +```solidity +library StdInvariant { + struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } + struct FuzzInterface { address addr; string[] artifacts; } + struct FuzzSelector { address addr; bytes4[] selectors; } +} +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod StdInvariant { + use super::*; + use alloy::sol_types as alloy_sol_types; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzArtifactSelector { + #[allow(missing_docs)] + pub artifact: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub selectors: alloy::sol_types::private::Vec< + 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 as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::String, + alloy::sol_types::private::Vec>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzArtifactSelector) -> Self { + (value.artifact, value.selectors) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzArtifactSelector { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + artifact: tuple.0, + selectors: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzArtifactSelector { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.artifact, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.selectors), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzArtifactSelector { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzArtifactSelector { + const NAME: &'static str = "FuzzArtifactSelector"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzArtifactSelector(string artifact,bytes4[] selectors)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.artifact, + ) + .0, + , + > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzArtifactSelector { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.artifact, + ) + + , + > as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.selectors, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.artifact, + out, + ); + , + > as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.selectors, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzInterface { address addr; string[] artifacts; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzInterface { + #[allow(missing_docs)] + pub addr: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub artifacts: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzInterface) -> Self { + (value.addr, value.artifacts) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzInterface { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + addr: tuple.0, + artifacts: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzInterface { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzInterface { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.addr, + ), + as alloy_sol_types::SolType>::tokenize(&self.artifacts), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzInterface { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzInterface { + const NAME: &'static str = "FuzzInterface"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzInterface(address addr,string[] artifacts)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.addr, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzInterface { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.addr, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.artifacts, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.addr, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.artifacts, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzSelector { address addr; bytes4[] selectors; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzSelector { + #[allow(missing_docs)] + pub addr: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub selectors: alloy::sol_types::private::Vec< + 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 as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Vec>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzSelector) -> Self { + (value.addr, value.selectors) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzSelector { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + addr: tuple.0, + selectors: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzSelector { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzSelector { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.addr, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.selectors), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzSelector { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzSelector { + const NAME: &'static str = "FuzzSelector"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzSelector(address addr,bytes4[] selectors)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.addr, + ) + .0, + , + > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzSelector { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.addr, + ) + + , + > as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.selectors, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.addr, + out, + ); + , + > as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.selectors, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. + +See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> StdInvariantInstance { + StdInvariantInstance::::new(address, provider) + } + /**A [`StdInvariant`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`StdInvariant`](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 StdInvariantInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for StdInvariantInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("StdInvariantInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. + +See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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 StdInvariantInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> StdInvariantInstance { + StdInvariantInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} +/** + +Generated by the following Solidity interface... +```solidity +library StdInvariant { + struct FuzzArtifactSelector { + string artifact; + bytes4[] selectors; + } + struct FuzzInterface { + address addr; + string[] artifacts; + } + struct FuzzSelector { + address addr; + bytes4[] selectors; + } +} + +interface AvalonWBTCLstStrategyForked { + event log(string); + event log_address(address); + event log_array(uint256[] val); + event log_array(int256[] val); + event log_array(address[] val); + event log_bytes(bytes); + event log_bytes32(bytes32); + event log_int(int256); + event log_named_address(string key, address val); + event log_named_array(string key, uint256[] val); + event log_named_array(string key, int256[] val); + event log_named_array(string key, address[] val); + event log_named_bytes(string key, bytes val); + event log_named_bytes32(string key, bytes32 val); + event log_named_decimal_int(string key, int256 val, uint256 decimals); + event log_named_decimal_uint(string key, uint256 val, uint256 decimals); + event log_named_int(string key, int256 val); + event log_named_string(string key, string val); + event log_named_uint(string key, uint256 val); + event log_string(string); + event log_uint(uint256); + event logs(bytes); + + function IS_TEST() external view returns (bool); + function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); + function excludeContracts() external view returns (address[] memory excludedContracts_); + function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); + function excludeSenders() external view returns (address[] memory excludedSenders_); + function failed() external view returns (bool); + function setUp() external; + function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; + function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); + function targetArtifacts() external view returns (string[] memory targetedArtifacts_); + function targetContracts() external view returns (address[] memory targetedContracts_); + function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); + function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); + function targetSenders() external view returns (address[] memory targetedSenders_); + function testWbtcLstStrategy() external; + function token() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "IS_TEST", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeArtifacts", + "inputs": [], + "outputs": [ + { + "name": "excludedArtifacts_", + "type": "string[]", + "internalType": "string[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeContracts", + "inputs": [], + "outputs": [ + { + "name": "excludedContracts_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeSelectors", + "inputs": [], + "outputs": [ + { + "name": "excludedSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzSelector[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeSenders", + "inputs": [], + "outputs": [ + { + "name": "excludedSenders_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "failed", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "setUp", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "simulateForkAndTransfer", + "inputs": [ + { + "name": "forkAtBlock", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "sender", + "type": "address", + "internalType": "address" + }, + { + "name": "receiver", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "targetArtifactSelectors", + "inputs": [], + "outputs": [ + { + "name": "targetedArtifactSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzArtifactSelector[]", + "components": [ + { + "name": "artifact", + "type": "string", + "internalType": "string" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetArtifacts", + "inputs": [], + "outputs": [ + { + "name": "targetedArtifacts_", + "type": "string[]", + "internalType": "string[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetContracts", + "inputs": [], + "outputs": [ + { + "name": "targetedContracts_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetInterfaces", + "inputs": [], + "outputs": [ + { + "name": "targetedInterfaces_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzInterface[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "artifacts", + "type": "string[]", + "internalType": "string[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetSelectors", + "inputs": [], + "outputs": [ + { + "name": "targetedSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzSelector[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetSenders", + "inputs": [], + "outputs": [ + { + "name": "targetedSenders_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "testWbtcLstStrategy", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "token", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IERC20" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "log", + "inputs": [ + { + "name": "", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_address", + "inputs": [ + { + "name": "", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "uint256[]", + "indexed": false, + "internalType": "uint256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "int256[]", + "indexed": false, + "internalType": "int256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "address[]", + "indexed": false, + "internalType": "address[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_bytes", + "inputs": [ + { + "name": "", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_bytes32", + "inputs": [ + { + "name": "", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_int", + "inputs": [ + { + "name": "", + "type": "int256", + "indexed": false, + "internalType": "int256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_address", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256[]", + "indexed": false, + "internalType": "uint256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256[]", + "indexed": false, + "internalType": "int256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "address[]", + "indexed": false, + "internalType": "address[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_bytes", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_bytes32", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_decimal_int", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256", + "indexed": false, + "internalType": "int256" + }, + { + "name": "decimals", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_decimal_uint", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "decimals", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_int", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256", + "indexed": false, + "internalType": "int256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_string", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_uint", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_string", + "inputs": [ + { + "name": "", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_uint", + "inputs": [ + { + "name": "", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "logs", + "inputs": [ + { + "name": "", + "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 AvalonWBTCLstStrategyForked { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x6080604052600c8054600160ff199182168117909255601f80549091169091179055348015602b575f5ffd5b50601f8054610100600160a81b0319167403c7054bcb39f7b2e5b2c7acb37583e32d70cfa300179055614270806100615f395ff3fe608060405234801561000f575f5ffd5b50600436106100fb575f3560e01c8063916a17c611610093578063e20c9f7111610063578063e20c9f71146101bb578063f9ce0e5a146101c3578063fa7626d4146101d6578063fc0c546a146101e3575f5ffd5b8063916a17c61461017e578063b0464fdc14610193578063b5508aa91461019b578063ba414fa6146101a3575f5ffd5b80633f7286f4116100ce5780633f7286f41461014457806342b01cfe1461014c57806366d9a9a01461015457806385226c8114610169575f5ffd5b80630a9254e4146100ff5780631ed7831c146101095780632ade3880146101275780633e5e3c231461013c575b5f5ffd5b61010761022d565b005b61011161026a565b60405161011e91906113a7565b60405180910390f35b61012f6102d7565b60405161011e919061142d565b610111610420565b61011161048b565b6101076104f6565b61015c610a57565b60405161011e919061157d565b610171610bd0565b60405161011e91906115fb565b610186610c9b565b60405161011e9190611652565b610186610d9e565b610171610ea1565b6101ab610f6c565b604051901515815260200161011e565b61011161103c565b6101076101d13660046116fe565b6110a7565b601f546101ab9060ff1681565b601f5461020890610100900473ffffffffffffffffffffffffffffffffffffffff1681565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200161011e565b610268625edcb2735a8e9774d67fe846c6f4311c073e2ac34b33646f73999999cf1046e68e36e1aa2e0e07105eddd1f08e6305f5e1006110a7565b565b606060168054806020026020016040519081016040528092919081815260200182805480156102cd57602002820191905f5260205f20905b815473ffffffffffffffffffffffffffffffffffffffff1681526001909101906020018083116102a2575b5050505050905090565b6060601e805480602002602001604051908101604052809291908181526020015f905b82821015610417575f848152602080822060408051808201825260028702909201805473ffffffffffffffffffffffffffffffffffffffff168352600181018054835181870281018701909452808452939591948681019491929084015b82821015610400578382905f5260205f200180546103759061173f565b80601f01602080910402602001604051908101604052809291908181526020018280546103a19061173f565b80156103ec5780601f106103c3576101008083540402835291602001916103ec565b820191905f5260205f20905b8154815290600101906020018083116103cf57829003601f168201915b505050505081526020019060010190610358565b5050505081525050815260200190600101906102fa565b50505050905090565b606060188054806020026020016040519081016040528092919081815260200182805480156102cd57602002820191905f5260205f2090815473ffffffffffffffffffffffffffffffffffffffff1681526001909101906020018083116102a2575050505050905090565b606060178054806020026020016040519081016040528092919081815260200182805480156102cd57602002820191905f5260205f2090815473ffffffffffffffffffffffffffffffffffffffff1681526001909101906020018083116102a2575050505050905090565b5f73541fd749419ca806a8bc7da8ac23d346f2df8b7790505f73cc0966d8418d412c599a6421b760a847eb169a8c90505f7349b072158564db36304518ffa37b1cfc13916a9073ba46fcc16b464d9787314167bdd9f1ce28405ba17f5664520240a46b4b3e9655c20cc3f9e08496a9b746a478e476ae3e04d6c8fc317f6899a7e13b655fa367208cb27c6eaa2410370d1565dc1f5f11853a1e8cbef03386866040516105a190611380565b73ffffffffffffffffffffffffffffffffffffffff96871681529486166020860152604085019390935260608401919091528316608083015290911660a082015260c001604051809103905ff0801580156105fe573d5f5f3e3d5ffd5b5090505f732e6500a7add9a788753a897e4e3477f651c612eb90505f7335b3f1bfe7cbe1e95a3dc2ad054eb6f0d4c879b690505f82826040516106409061138d565b73ffffffffffffffffffffffffffffffffffffffff928316815291166020820152604001604051809103905ff08015801561067d573d5f5f3e3d5ffd5b5090505f848260405161068f9061139a565b73ffffffffffffffffffffffffffffffffffffffff928316815291166020820152604001604051809103905ff0801580156106cc573d5f5f3e3d5ffd5b506040517f06447d5600000000000000000000000000000000000000000000000000000000815273999999cf1046e68e36e1aa2e0e07105eddd1f08e6004820152909150737109709ecfa91a80626ff3989d68f67f5b1dd12d906306447d56906024015f604051808303815f87803b158015610746575f5ffd5b505af1158015610758573d5f5f3e3d5ffd5b5050601f546040517f095ea7b300000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff85811660048301526305f5e1006024830152610100909204909116925063095ea7b391506044016020604051808303815f875af11580156107db573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906107ff9190611790565b506040517f70a08231000000000000000000000000000000000000000000000000000000008152600160048201526108979073ffffffffffffffffffffffffffffffffffffffff8616906370a0823190602401602060405180830381865afa15801561086d573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061089191906117b6565b5f6112fd565b601f54604080516020810182525f815290517f7f814f3500000000000000000000000000000000000000000000000000000000815261010090920473ffffffffffffffffffffffffffffffffffffffff90811660048401526305f5e10060248401526001604484015290516064830152821690637f814f35906084015f604051808303815f87803b15801561092a575f5ffd5b505af115801561093c573d5f5f3e3d5ffd5b50505050737109709ecfa91a80626ff3989d68f67f5b1dd12d73ffffffffffffffffffffffffffffffffffffffff166390c5013b6040518163ffffffff1660e01b81526004015f604051808303815f87803b158015610999575f5ffd5b505af11580156109ab573d5f5f3e3d5ffd5b50506040517f70a0823100000000000000000000000000000000000000000000000000000000815260016004820152610a4e925073ffffffffffffffffffffffffffffffffffffffff871691506370a0823190602401602060405180830381865afa158015610a1c573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610a4091906117b6565b670de0b6b3a76400006112fd565b50505050505050565b6060601b805480602002602001604051908101604052809291908181526020015f905b82821015610417578382905f5260205f2090600202016040518060400160405290815f82018054610aaa9061173f565b80601f0160208091040260200160405190810160405280929190818152602001828054610ad69061173f565b8015610b215780601f10610af857610100808354040283529160200191610b21565b820191905f5260205f20905b815481529060010190602001808311610b0457829003601f168201915b5050505050815260200160018201805480602002602001604051908101604052809291908181526020018280548015610bb857602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191681526020019060040190602082600301049283019260010382029150808411610b655790505b50505050508152505081526020019060010190610a7a565b6060601a805480602002602001604051908101604052809291908181526020015f905b82821015610417578382905f5260205f20018054610c109061173f565b80601f0160208091040260200160405190810160405280929190818152602001828054610c3c9061173f565b8015610c875780601f10610c5e57610100808354040283529160200191610c87565b820191905f5260205f20905b815481529060010190602001808311610c6a57829003601f168201915b505050505081526020019060010190610bf3565b6060601d805480602002602001604051908101604052809291908181526020015f905b82821015610417575f84815260209081902060408051808201825260028602909201805473ffffffffffffffffffffffffffffffffffffffff168352600181018054835181870281018701909452808452939491938583019392830182828015610d8657602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191681526020019060040190602082600301049283019260010382029150808411610d335790505b50505050508152505081526020019060010190610cbe565b6060601c805480602002602001604051908101604052809291908181526020015f905b82821015610417575f84815260209081902060408051808201825260028602909201805473ffffffffffffffffffffffffffffffffffffffff168352600181018054835181870281018701909452808452939491938583019392830182828015610e8957602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191681526020019060040190602082600301049283019260010382029150808411610e365790505b50505050508152505081526020019060010190610dc1565b60606019805480602002602001604051908101604052809291908181526020015f905b82821015610417578382905f5260205f20018054610ee19061173f565b80601f0160208091040260200160405190810160405280929190818152602001828054610f0d9061173f565b8015610f585780601f10610f2f57610100808354040283529160200191610f58565b820191905f5260205f20905b815481529060010190602001808311610f3b57829003601f168201915b505050505081526020019060010190610ec4565b6008545f9060ff1615610f83575060085460ff1690565b6040517f667f9d70000000000000000000000000000000000000000000000000000000008152737109709ecfa91a80626ff3989d68f67f5b1dd12d600482018190527f6661696c6564000000000000000000000000000000000000000000000000000060248301525f9163667f9d7090604401602060405180830381865afa158015611011573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061103591906117b6565b1415905090565b606060158054806020026020016040519081016040528092919081815260200182805480156102cd57602002820191905f5260205f2090815473ffffffffffffffffffffffffffffffffffffffff1681526001909101906020018083116102a2575050505050905090565b6040517ff877cb1900000000000000000000000000000000000000000000000000000000815260206004820152601760248201527f424f425f50524f445f5055424c49435f5250435f55524c0000000000000000006044820152737109709ecfa91a80626ff3989d68f67f5b1dd12d906371ee464d90829063f877cb19906064015f60405180830381865afa158015611142573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d908101601f1916820160405261116991908101906117fa565b866040518363ffffffff1660e01b81526004016111879291906118ae565b6020604051808303815f875af11580156111a3573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906111c791906117b6565b506040517fca669fa700000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff84166004820152737109709ecfa91a80626ff3989d68f67f5b1dd12d9063ca669fa7906024015f604051808303815f87803b158015611240575f5ffd5b505af1158015611252573d5f5f3e3d5ffd5b5050601f546040517fa9059cbb00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff868116600483015260248201869052610100909204909116925063a9059cbb91506044016020604051808303815f875af11580156112d2573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906112f69190611790565b5050505050565b6040517f98296c540000000000000000000000000000000000000000000000000000000081526004810183905260248101829052737109709ecfa91a80626ff3989d68f67f5b1dd12d906398296c54906044015f6040518083038186803b158015611366575f5ffd5b505afa158015611378573d5f5f3e3d5ffd5b505050505050565b610f2d806118d083390190565b610d1e806127fd83390190565b610d208061351b83390190565b602080825282518282018190525f918401906040840190835b818110156113f457835173ffffffffffffffffffffffffffffffffffffffff168352602093840193909201916001016113c0565b509095945050505050565b5f81518084528060208401602086015e5f602082860101526020601f19601f83011685010191505092915050565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b8281101561151557603f198786030184528151805173ffffffffffffffffffffffffffffffffffffffff168652602090810151604082880181905281519088018190529101906060600582901b8801810191908801905f5b818110156114fb577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa08a85030183526114e58486516113ff565b60209586019590945092909201916001016114ab565b509197505050602094850194929092019150600101611453565b50929695505050505050565b5f8151808452602084019350602083015f5b828110156115735781517fffffffff0000000000000000000000000000000000000000000000000000000016865260209586019590910190600101611533565b5093949350505050565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b8281101561151557603f1987860301845281518051604087526115c960408801826113ff565b90506020820151915086810360208801526115e48183611521565b9650505060209384019391909101906001016115a3565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b8281101561151557603f1987860301845261163d8583516113ff565b94506020938401939190910190600101611621565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b8281101561151557603f19878603018452815173ffffffffffffffffffffffffffffffffffffffff815116865260208101519050604060208701526116c06040870182611521565b9550506020938401939190910190600101611678565b803573ffffffffffffffffffffffffffffffffffffffff811681146116f9575f5ffd5b919050565b5f5f5f5f60808587031215611711575f5ffd5b84359350611721602086016116d6565b925061172f604086016116d6565b9396929550929360600135925050565b600181811c9082168061175357607f821691505b60208210810361178a577f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b50919050565b5f602082840312156117a0575f5ffd5b815180151581146117af575f5ffd5b9392505050565b5f602082840312156117c6575f5ffd5b5051919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b5f6020828403121561180a575f5ffd5b815167ffffffffffffffff811115611820575f5ffd5b8201601f81018413611830575f5ffd5b805167ffffffffffffffff81111561184a5761184a6117cd565b604051601f19603f601f19601f8501160116810181811067ffffffffffffffff8211171561187a5761187a6117cd565b604052818152828201602001861015611891575f5ffd5b8160208401602083015e5f91810160200191909152949350505050565b604081525f6118c060408301856113ff565b9050826020830152939250505056fe610140604052348015610010575f5ffd5b50604051610f2d380380610f2d83398101604081905261002f91610073565b6001600160a01b0395861660805293851660a05260c09290925260e05282166101005216610120526100e3565b6001600160a01b0381168114610070575f5ffd5b50565b5f5f5f5f5f5f60c08789031215610088575f5ffd5b86516100938161005c565b60208801519096506100a48161005c565b6040880151606089015160808a015192975090955093506100c48161005c565b60a08801519092506100d58161005c565b809150509295509295509295565b60805160a05160c05160e0516101005161012051610dc66101675f395f818161012e015281816104fc015261053e01525f8181610155015261035201525f81816101b101526103c101525f818161017c015261028801525f818160df0152818161037401526103f001525f8181608e0152818161023b01526102b70152610dc65ff3fe608060405234801561000f575f5ffd5b5060043610610085575f3560e01c8063ad747de611610058578063ad747de614610129578063b9937ccb14610150578063c8c7f70114610177578063e34cef86146101ac575f5ffd5b806306af019a146100895780634e3df3f4146100da57806350634c0e146101015780637f814f3514610116575b5f5ffd5b6100b07f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020015b60405180910390f35b6100b07f000000000000000000000000000000000000000000000000000000000000000081565b61011461010f366004610b67565b6101d3565b005b610114610124366004610c29565b6101fd565b6100b07f000000000000000000000000000000000000000000000000000000000000000081565b6100b07f000000000000000000000000000000000000000000000000000000000000000081565b61019e7f000000000000000000000000000000000000000000000000000000000000000081565b6040519081526020016100d1565b61019e7f000000000000000000000000000000000000000000000000000000000000000081565b5f818060200190518101906101e89190610cad565b90506101f6858585846101fd565b5050505050565b61021f73ffffffffffffffffffffffffffffffffffffffff851633308661059a565b61026073ffffffffffffffffffffffffffffffffffffffff85167f00000000000000000000000000000000000000000000000000000000000000008561065e565b6040517f6d724ead0000000000000000000000000000000000000000000000000000000081527f00000000000000000000000000000000000000000000000000000000000000006004820152602481018490525f907f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1690636d724ead906044016020604051808303815f875af1158015610312573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103369190610cd1565b905061039973ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000167f00000000000000000000000000000000000000000000000000000000000000008361065e565b6040517f6d724ead0000000000000000000000000000000000000000000000000000000081527f00000000000000000000000000000000000000000000000000000000000000006004820152602481018290525f907f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1690636d724ead906044016020604051808303815f875af115801561044b573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061046f9190610cd1565b83519091508110156104e2576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601a60248201527f496e73756666696369656e74206f757470757420616d6f756e7400000000000060448201526064015b60405180910390fd5b61052373ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000168583610759565b6040805173ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000168152602081018390527f0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d910160405180910390a1505050505050565b60405173ffffffffffffffffffffffffffffffffffffffff808516602483015283166044820152606481018290526106589085907f23b872dd00000000000000000000000000000000000000000000000000000000906084015b60408051601f198184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff00000000000000000000000000000000000000000000000000000000909316929092179091526107b4565b50505050565b6040517fdd62ed3e00000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff83811660248301525f91839186169063dd62ed3e90604401602060405180830381865afa1580156106d2573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906106f69190610cd1565b6107009190610ce8565b60405173ffffffffffffffffffffffffffffffffffffffff85166024820152604481018290529091506106589085907f095ea7b300000000000000000000000000000000000000000000000000000000906064016105f4565b60405173ffffffffffffffffffffffffffffffffffffffff83166024820152604481018290526107af9084907fa9059cbb00000000000000000000000000000000000000000000000000000000906064016105f4565b505050565b5f610815826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166108bf9092919063ffffffff16565b8051909150156107af57808060200190518101906108339190610d26565b6107af576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f7420737563636565640000000000000000000000000000000000000000000060648201526084016104d9565b60606108cd84845f856108d7565b90505b9392505050565b606082471015610969576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c000000000000000000000000000000000000000000000000000060648201526084016104d9565b73ffffffffffffffffffffffffffffffffffffffff85163b6109e7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e747261637400000060448201526064016104d9565b5f5f8673ffffffffffffffffffffffffffffffffffffffff168587604051610a0f9190610d45565b5f6040518083038185875af1925050503d805f8114610a49576040519150601f19603f3d011682016040523d82523d5f602084013e610a4e565b606091505b5091509150610a5e828286610a69565b979650505050505050565b60608315610a785750816108d0565b825115610a885782518084602001fd5b816040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104d99190610d5b565b73ffffffffffffffffffffffffffffffffffffffff81168114610add575f5ffd5b50565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b6040516020810167ffffffffffffffff81118282101715610b3057610b30610ae0565b60405290565b604051601f8201601f1916810167ffffffffffffffff81118282101715610b5f57610b5f610ae0565b604052919050565b5f5f5f5f60808587031215610b7a575f5ffd5b8435610b8581610abc565b9350602085013592506040850135610b9c81610abc565b9150606085013567ffffffffffffffff811115610bb7575f5ffd5b8501601f81018713610bc7575f5ffd5b803567ffffffffffffffff811115610be157610be1610ae0565b610bf46020601f19601f84011601610b36565b818152886020838501011115610c08575f5ffd5b816020840160208301375f6020838301015280935050505092959194509250565b5f5f5f5f8486036080811215610c3d575f5ffd5b8535610c4881610abc565b9450602086013593506040860135610c5f81610abc565b925060207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa082011215610c90575f5ffd5b50610c99610b0d565b606095909501358552509194909350909190565b5f6020828403128015610cbe575f5ffd5b50610cc7610b0d565b9151825250919050565b5f60208284031215610ce1575f5ffd5b5051919050565b80820180821115610d20577f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b92915050565b5f60208284031215610d36575f5ffd5b815180151581146108d0575f5ffd5b5f82518060208501845e5f920191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f8301168401019150509291505056fea2646970667358221220d2388cb3dc7aa6f5a2eb75417d11059be13c8c9eabe5d7eadb1b561f937ff69164736f6c634300081c003360c060405234801561000f575f5ffd5b50604051610d1e380380610d1e83398101604081905261002e9161005c565b6001600160a01b039182166080521660a052610094565b6001600160a01b0381168114610059575f5ffd5b50565b5f5f6040838503121561006d575f5ffd5b825161007881610045565b602084015190925061008981610045565b809150509250929050565b60805160a051610c486100d65f395f8181605301528181610155015261028901525f818160a3015281816101c10152818161032801526104620152610c485ff3fe608060405234801561000f575f5ffd5b506004361061004a575f3560e01c806316f0115b1461004e57806325e2d6251461009e57806350634c0e146100c55780637f814f35146100da575b5f5ffd5b6100757f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200160405180910390f35b6100757f000000000000000000000000000000000000000000000000000000000000000081565b6100d86100d33660046109ce565b6100ed565b005b6100d86100e8366004610a90565b610117565b5f818060200190518101906101029190610b14565b905061011085858584610117565b5050505050565b61013973ffffffffffffffffffffffffffffffffffffffff85163330866104bf565b61017a73ffffffffffffffffffffffffffffffffffffffff85167f000000000000000000000000000000000000000000000000000000000000000085610583565b6040517f70a0823100000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff83811660048301525f917f0000000000000000000000000000000000000000000000000000000000000000909116906370a0823190602401602060405180830381865afa158015610208573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061022c9190610b38565b6040517f617ba03700000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff87811660048301526024820187905285811660448301525f60648301529192507f00000000000000000000000000000000000000000000000000000000000000009091169063617ba037906084015f604051808303815f87803b1580156102cc575f5ffd5b505af11580156102de573d5f5f3e3d5ffd5b50506040517f70a0823100000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff86811660048301525f93507f00000000000000000000000000000000000000000000000000000000000000001691506370a0823190602401602060405180830381865afa15801561036e573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103929190610b38565b90508181116103e85760405162461bcd60e51b815260206004820152601c60248201527f496e73756666696369656e7420737570706c792070726f76696465640000000060448201526064015b60405180910390fd5b5f6103f38383610b7c565b84519091508110156104475760405162461bcd60e51b815260206004820152601a60248201527f496e73756666696369656e74206f757470757420616d6f756e7400000000000060448201526064016103df565b6040805173ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000168152602081018390527f0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d910160405180910390a150505050505050565b60405173ffffffffffffffffffffffffffffffffffffffff8085166024830152831660448201526064810182905261057d9085907f23b872dd00000000000000000000000000000000000000000000000000000000906084015b60408051601f198184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff000000000000000000000000000000000000000000000000000000009093169290921790915261067e565b50505050565b6040517fdd62ed3e00000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff83811660248301525f91839186169063dd62ed3e90604401602060405180830381865afa1580156105f7573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061061b9190610b38565b6106259190610b95565b60405173ffffffffffffffffffffffffffffffffffffffff851660248201526044810182905290915061057d9085907f095ea7b30000000000000000000000000000000000000000000000000000000090606401610519565b5f6106df826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166107749092919063ffffffff16565b80519091501561076f57808060200190518101906106fd9190610ba8565b61076f5760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f7420737563636565640000000000000000000000000000000000000000000060648201526084016103df565b505050565b606061078284845f8561078c565b90505b9392505050565b6060824710156108045760405162461bcd60e51b815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c000000000000000000000000000000000000000000000000000060648201526084016103df565b73ffffffffffffffffffffffffffffffffffffffff85163b6108685760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e747261637400000060448201526064016103df565b5f5f8673ffffffffffffffffffffffffffffffffffffffff1685876040516108909190610bc7565b5f6040518083038185875af1925050503d805f81146108ca576040519150601f19603f3d011682016040523d82523d5f602084013e6108cf565b606091505b50915091506108df8282866108ea565b979650505050505050565b606083156108f9575081610785565b8251156109095782518084602001fd5b8160405162461bcd60e51b81526004016103df9190610bdd565b73ffffffffffffffffffffffffffffffffffffffff81168114610944575f5ffd5b50565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b6040516020810167ffffffffffffffff8111828210171561099757610997610947565b60405290565b604051601f8201601f1916810167ffffffffffffffff811182821017156109c6576109c6610947565b604052919050565b5f5f5f5f608085870312156109e1575f5ffd5b84356109ec81610923565b9350602085013592506040850135610a0381610923565b9150606085013567ffffffffffffffff811115610a1e575f5ffd5b8501601f81018713610a2e575f5ffd5b803567ffffffffffffffff811115610a4857610a48610947565b610a5b6020601f19601f8401160161099d565b818152886020838501011115610a6f575f5ffd5b816020840160208301375f6020838301015280935050505092959194509250565b5f5f5f5f8486036080811215610aa4575f5ffd5b8535610aaf81610923565b9450602086013593506040860135610ac681610923565b925060207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa082011215610af7575f5ffd5b50610b00610974565b606095909501358552509194909350909190565b5f6020828403128015610b25575f5ffd5b50610b2e610974565b9151825250919050565b5f60208284031215610b48575f5ffd5b5051919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b81810381811115610b8f57610b8f610b4f565b92915050565b80820180821115610b8f57610b8f610b4f565b5f60208284031215610bb8575f5ffd5b81518015158114610785575f5ffd5b5f82518060208501845e5f920191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f8301168401019150509291505056fea264697066735822122082cf598164946b8f719c4d82ef5ef60e3dda57bec73de3e887b66e790bf7577164736f6c634300081c003360c060405234801561000f575f5ffd5b50604051610d20380380610d2083398101604081905261002e9161005c565b6001600160a01b039182166080521660a052610094565b6001600160a01b0381168114610059575f5ffd5b50565b5f5f6040838503121561006d575f5ffd5b825161007881610045565b602084015190925061008981610045565b809150509250929050565b60805160a051610c4a6100d65f395f818160530152818161037501526103f501525f818160cb01528181610155015281816101df015261023b0152610c4a5ff3fe608060405234801561000f575f5ffd5b506004361061004a575f3560e01c806346226c311461004e57806350634c0e1461009e5780637f814f35146100b3578063f2234cf9146100c6575b5f5ffd5b6100757f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200160405180910390f35b6100b16100ac3660046109d0565b6100ed565b005b6100b16100c1366004610a92565b610117565b6100757f000000000000000000000000000000000000000000000000000000000000000081565b5f818060200190518101906101029190610b16565b905061011085858584610117565b5050505050565b61013973ffffffffffffffffffffffffffffffffffffffff8516333086610454565b61017a73ffffffffffffffffffffffffffffffffffffffff85167f000000000000000000000000000000000000000000000000000000000000000085610518565b604080516020810182525f815290517f7f814f3500000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff868116600483015260248201869052306044830152915160648201527f000000000000000000000000000000000000000000000000000000000000000090911690637f814f35906084015f604051808303815f87803b158015610222575f5ffd5b505af1158015610234573d5f5f3e3d5ffd5b505050505f7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663ad747de66040518163ffffffff1660e01b8152600401602060405180830381865afa1580156102a2573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906102c69190610b3a565b6040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201529091505f9073ffffffffffffffffffffffffffffffffffffffff8316906370a0823190602401602060405180830381865afa158015610333573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103579190610b55565b905061039a73ffffffffffffffffffffffffffffffffffffffff83167f000000000000000000000000000000000000000000000000000000000000000083610518565b6040517f7f814f3500000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8381166004830152602482018390528581166044830152845160648301527f00000000000000000000000000000000000000000000000000000000000000001690637f814f35906084015f604051808303815f87803b158015610436575f5ffd5b505af1158015610448573d5f5f3e3d5ffd5b50505050505050505050565b60405173ffffffffffffffffffffffffffffffffffffffff808516602483015283166044820152606481018290526105129085907f23b872dd00000000000000000000000000000000000000000000000000000000906084015b60408051601f198184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff0000000000000000000000000000000000000000000000000000000090931692909217909152610613565b50505050565b6040517fdd62ed3e00000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff83811660248301525f91839186169063dd62ed3e90604401602060405180830381865afa15801561058c573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906105b09190610b55565b6105ba9190610b6c565b60405173ffffffffffffffffffffffffffffffffffffffff85166024820152604481018290529091506105129085907f095ea7b300000000000000000000000000000000000000000000000000000000906064016104ae565b5f610674826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166107289092919063ffffffff16565b80519091501561072357808060200190518101906106929190610baa565b610723576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f7420737563636565640000000000000000000000000000000000000000000060648201526084015b60405180910390fd5b505050565b606061073684845f85610740565b90505b9392505050565b6060824710156107d2576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c0000000000000000000000000000000000000000000000000000606482015260840161071a565b73ffffffffffffffffffffffffffffffffffffffff85163b610850576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015260640161071a565b5f5f8673ffffffffffffffffffffffffffffffffffffffff1685876040516108789190610bc9565b5f6040518083038185875af1925050503d805f81146108b2576040519150601f19603f3d011682016040523d82523d5f602084013e6108b7565b606091505b50915091506108c78282866108d2565b979650505050505050565b606083156108e1575081610739565b8251156108f15782518084602001fd5b816040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161071a9190610bdf565b73ffffffffffffffffffffffffffffffffffffffff81168114610946575f5ffd5b50565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b6040516020810167ffffffffffffffff8111828210171561099957610999610949565b60405290565b604051601f8201601f1916810167ffffffffffffffff811182821017156109c8576109c8610949565b604052919050565b5f5f5f5f608085870312156109e3575f5ffd5b84356109ee81610925565b9350602085013592506040850135610a0581610925565b9150606085013567ffffffffffffffff811115610a20575f5ffd5b8501601f81018713610a30575f5ffd5b803567ffffffffffffffff811115610a4a57610a4a610949565b610a5d6020601f19601f8401160161099f565b818152886020838501011115610a71575f5ffd5b816020840160208301375f6020838301015280935050505092959194509250565b5f5f5f5f8486036080811215610aa6575f5ffd5b8535610ab181610925565b9450602086013593506040860135610ac881610925565b925060207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa082011215610af9575f5ffd5b50610b02610976565b606095909501358552509194909350909190565b5f6020828403128015610b27575f5ffd5b50610b30610976565b9151825250919050565b5f60208284031215610b4a575f5ffd5b815161073981610925565b5f60208284031215610b65575f5ffd5b5051919050565b80820180821115610ba4577f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b92915050565b5f60208284031215610bba575f5ffd5b81518015158114610739575f5ffd5b5f82518060208501845e5f920191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f8301168401019150509291505056fea26469706673582212200f900405043b43af2c7f752cfe8ca7ffd733511a053e1a3e8ad4b3001398002464736f6c634300081c0033a264697066735822122067e5f479550b507c36a44d426091fd98cf68ade86c43be783cddde02e07ef32864736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\x80`@R`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15`+W__\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16t\x03\xC7\x05K\xCB9\xF7\xB2\xE5\xB2\xC7\xAC\xB3u\x83\xE3-p\xCF\xA3\0\x17\x90UaBp\x80a\0a_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xFBW_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\x93W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x01\xBBW\x80c\xF9\xCE\x0EZ\x14a\x01\xC3W\x80c\xFAv&\xD4\x14a\x01\xD6W\x80c\xFC\x0CTj\x14a\x01\xE3W__\xFD[\x80c\x91j\x17\xC6\x14a\x01~W\x80c\xB0FO\xDC\x14a\x01\x93W\x80c\xB5P\x8A\xA9\x14a\x01\x9BW\x80c\xBAAO\xA6\x14a\x01\xA3W__\xFD[\x80c?r\x86\xF4\x11a\0\xCEW\x80c?r\x86\xF4\x14a\x01DW\x80cB\xB0\x1C\xFE\x14a\x01LW\x80cf\xD9\xA9\xA0\x14a\x01TW\x80c\x85\"l\x81\x14a\x01iW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x1E\xD7\x83\x1C\x14a\x01\tW\x80c*\xDE8\x80\x14a\x01'W\x80c>^<#\x14a\x01*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x10\xA7V[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\0W\x83\x82\x90_R` _ \x01\x80Ta\x03u\x90a\x17?V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xA1\x90a\x17?V[\x80\x15a\x03\xECW\x80`\x1F\x10a\x03\xC3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xECV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xCFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03XV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xFAV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[_sT\x1F\xD7IA\x9C\xA8\x06\xA8\xBC}\xA8\xAC#\xD3F\xF2\xDF\x8Bw\x90P_s\xCC\tf\xD8A\x8DA,Y\x9Ad!\xB7`\xA8G\xEB\x16\x9A\x8C\x90P_sI\xB0r\x15\x85d\xDB60E\x18\xFF\xA3{\x1C\xFC\x13\x91j\x90s\xBAF\xFC\xC1kFM\x97\x871Ag\xBD\xD9\xF1\xCE(@[\xA1\x7FVdR\x02@\xA4kK>\x96U\xC2\x0C\xC3\xF9\xE0\x84\x96\xA9\xB7F\xA4x\xE4v\xAE>\x04\xD6\xC8\xFC1\x7Fh\x99\xA7\xE1;e_\xA3g \x8C\xB2|n\xAA$\x107\r\x15e\xDC\x1F_\x11\x85:\x1E\x8C\xBE\xF03\x86\x86`@Qa\x05\xA1\x90a\x13\x80V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x96\x87\x16\x81R\x94\x86\x16` \x86\x01R`@\x85\x01\x93\x90\x93R``\x84\x01\x91\x90\x91R\x83\x16`\x80\x83\x01R\x90\x91\x16`\xA0\x82\x01R`\xC0\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x05\xFEW=__>=_\xFD[P\x90P_s.e\0\xA7\xAD\xD9\xA7\x88u:\x89~N4w\xF6Q\xC6\x12\xEB\x90P_s5\xB3\xF1\xBF\xE7\xCB\xE1\xE9Z=\xC2\xAD\x05N\xB6\xF0\xD4\xC8y\xB6\x90P_\x82\x82`@Qa\x06@\x90a\x13\x8DV[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x06}W=__>=_\xFD[P\x90P_\x84\x82`@Qa\x06\x8F\x90a\x13\x9AV[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x06\xCCW=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07FW__\xFD[PZ\xF1\x15\x80\x15a\x07XW=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x07\xDBW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xFF\x91\x90a\x17\x90V[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\x81R`\x01`\x04\x82\x01Ra\x08\x97\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\x08mW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\x91\x91\x90a\x17\xB6V[_a\x12\xFDV[`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t*W__\xFD[PZ\xF1\x15\x80\x15a\t=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t\x99W__\xFD[PZ\xF1\x15\x80\x15a\t\xABW=__>=_\xFD[PP`@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\x81R`\x01`\x04\x82\x01Ra\nN\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\n\x1CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n@\x91\x90a\x17\xB6V[g\r\xE0\xB6\xB3\xA7d\0\0a\x12\xFDV[PPPPPPPV[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\n\xAA\x90a\x17?V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n\xD6\x90a\x17?V[\x80\x15a\x0B!W\x80`\x1F\x10a\n\xF8Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B!V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\x04W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x0B\xB8W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0BeW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\nzV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\x0C\x10\x90a\x17?V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C<\x90a\x17?V[\x80\x15a\x0C\x87W\x80`\x1F\x10a\x0C^Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C\x87V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0CjW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0B\xF3V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\x86W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r3W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xBEV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0E\x89W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0E6W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\r\xC1V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\x0E\xE1\x90a\x17?V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F\r\x90a\x17?V[\x80\x15a\x0FXW\x80`\x1F\x10a\x0F/Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0FXV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F;W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0E\xC4V[`\x08T_\x90`\xFF\x16\x15a\x0F\x83WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\x11W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x105\x91\x90a\x17\xB6V[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11BW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x11i\x91\x90\x81\x01\x90a\x17\xFAV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x11\x87\x92\x91\x90a\x18\xAEV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11\xA3W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\xC7\x91\x90a\x17\xB6V[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12@W__\xFD[PZ\xF1\x15\x80\x15a\x12RW=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x12\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xF6\x91\x90a\x17\x90V[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x13fW__\xFD[PZ\xFA\x15\x80\x15a\x13xW=__>=_\xFD[PPPPPPV[a\x0F-\x80a\x18\xD0\x839\x01\x90V[a\r\x1E\x80a'\xFD\x839\x01\x90V[a\r \x80a5\x1B\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x13\xF4W\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\x13\xC0V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x15W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x14\xFBW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x14\xE5\x84\x86Qa\x13\xFFV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x14\xABV[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x14SV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x15sW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x153V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x15W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x15\xC9`@\x88\x01\x82a\x13\xFFV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x15\xE4\x81\x83a\x15!V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\xA3V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x15W`?\x19\x87\x86\x03\x01\x84Ra\x16=\x85\x83Qa\x13\xFFV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16!V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x15W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x16\xC0`@\x87\x01\x82a\x15!V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16xV[\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\x16\xF9W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x17\x11W__\xFD[\x845\x93Pa\x17!` \x86\x01a\x16\xD6V[\x92Pa\x17/`@\x86\x01a\x16\xD6V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x17SW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x17\x8AW\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17\xA0W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x17\xAFW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x17\xC6W__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x18\nW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18 W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x180W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18JWa\x18Ja\x17\xCDV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x18zWa\x18za\x17\xCDV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x18\x91W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x18\xC0`@\x83\x01\x85a\x13\xFFV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFEa\x01@`@R4\x80\x15a\0\x10W__\xFD[P`@Qa\x0F-8\x03\x80a\x0F-\x839\x81\x01`@\x81\x90Ra\0/\x91a\0sV[`\x01`\x01`\xA0\x1B\x03\x95\x86\x16`\x80R\x93\x85\x16`\xA0R`\xC0\x92\x90\x92R`\xE0R\x82\x16a\x01\0R\x16a\x01 Ra\0\xE3V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0pW__\xFD[PV[______`\xC0\x87\x89\x03\x12\x15a\0\x88W__\xFD[\x86Qa\0\x93\x81a\0\\V[` \x88\x01Q\x90\x96Pa\0\xA4\x81a\0\\V[`@\x88\x01Q``\x89\x01Q`\x80\x8A\x01Q\x92\x97P\x90\x95P\x93Pa\0\xC4\x81a\0\\V[`\xA0\x88\x01Q\x90\x92Pa\0\xD5\x81a\0\\V[\x80\x91PP\x92\x95P\x92\x95P\x92\x95V[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\r\xC6a\x01g_9_\x81\x81a\x01.\x01R\x81\x81a\x04\xFC\x01Ra\x05>\x01R_\x81\x81a\x01U\x01Ra\x03R\x01R_\x81\x81a\x01\xB1\x01Ra\x03\xC1\x01R_\x81\x81a\x01|\x01Ra\x02\x88\x01R_\x81\x81`\xDF\x01R\x81\x81a\x03t\x01Ra\x03\xF0\x01R_\x81\x81`\x8E\x01R\x81\x81a\x02;\x01Ra\x02\xB7\x01Ra\r\xC6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\x85W_5`\xE0\x1C\x80c\xADt}\xE6\x11a\0XW\x80c\xADt}\xE6\x14a\x01)W\x80c\xB9\x93|\xCB\x14a\x01PW\x80c\xC8\xC7\xF7\x01\x14a\x01wW\x80c\xE3L\xEF\x86\x14a\x01\xACW__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0\x89W\x80cN=\xF3\xF4\x14a\0\xDAW\x80cPcL\x0E\x14a\x01\x01W\x80c\x7F\x81O5\x14a\x01\x16W[__\xFD[a\0\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\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\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\x81V[a\x01\x14a\x01\x0F6`\x04a\x0BgV[a\x01\xD3V[\0[a\x01\x14a\x01$6`\x04a\x0C)V[a\x01\xFDV[a\0\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\x81V[a\0\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\x81V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xD1V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\xE8\x91\x90a\x0C\xADV[\x90Pa\x01\xF6\x85\x85\x85\x84a\x01\xFDV[PPPPPV[a\x02\x1Fs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x9AV[a\x02`s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x036\x91\x90a\x0C\xD1V[\x90Pa\x03\x99s\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\x7F\0\0\0\0\0\0\0\0\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\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x82\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04KW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04o\x91\x90a\x0C\xD1V[\x83Q\x90\x91P\x81\x10\x15a\x04\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[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\x85\x83a\x07YV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x06X\x90\x85\x90\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\x90`\x84\x01[`@\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\x07\xB4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF6\x91\x90a\x0C\xD1V[a\x07\0\x91\x90a\x0C\xE8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x06X\x90\x85\x90\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\x90`d\x01a\x05\xF4V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07\xAF\x90\x84\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\x90`d\x01a\x05\xF4V[PPPV[_a\x08\x15\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\x08\xBF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\xAFW\x80\x80` \x01\x90Q\x81\x01\x90a\x083\x91\x90a\r&V[a\x07\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\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\x04\xD9V[``a\x08\xCD\x84\x84_\x85a\x08\xD7V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\tiW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x04\xD9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\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`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x04\xD9V[__\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\n\x0F\x91\x90a\rEV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\nIW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\nNV[``\x91P[P\x91P\x91Pa\n^\x82\x82\x86a\niV[\x97\x96PPPPPPPV[``\x83\x15a\nxWP\x81a\x08\xD0V[\x82Q\x15a\n\x88W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x04\xD9\x91\x90a\r[V[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\xDDW__\xFD[PV[\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\x0B0Wa\x0B0a\n\xE0V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0B_Wa\x0B_a\n\xE0V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0BzW__\xFD[\x845a\x0B\x85\x81a\n\xBCV[\x93P` \x85\x015\x92P`@\x85\x015a\x0B\x9C\x81a\n\xBCV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xB7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\x0B\xC7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xE1Wa\x0B\xE1a\n\xE0V[a\x0B\xF4` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0B6V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0C\x08W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0C=W__\xFD[\x855a\x0CH\x81a\n\xBCV[\x94P` \x86\x015\x93P`@\x86\x015a\x0C_\x81a\n\xBCV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0C\x90W__\xFD[Pa\x0C\x99a\x0B\rV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0C\xBEW__\xFD[Pa\x0C\xC7a\x0B\rV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C\xE1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\r 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[_` \x82\x84\x03\x12\x15a\r6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x08\xD0W__\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\xFE\xA2dipfsX\"\x12 \xD28\x8C\xB3\xDCz\xA6\xF5\xA2\xEBuA}\x11\x05\x9B\xE1<\x8C\x9E\xAB\xE5\xD7\xEA\xDB\x1BV\x1F\x93\x7F\xF6\x91dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\x1E8\x03\x80a\r\x1E\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CHa\0\xD6_9_\x81\x81`S\x01R\x81\x81a\x01U\x01Ra\x02\x89\x01R_\x81\x81`\xA3\x01R\x81\x81a\x01\xC1\x01R\x81\x81a\x03(\x01Ra\x04b\x01Ra\x0CH_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x16\xF0\x11[\x14a\0NW\x80c%\xE2\xD6%\x14a\0\x9EW\x80cPcL\x0E\x14a\0\xC5W\x80c\x7F\x81O5\x14a\0\xDAW[__\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\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[a\0\xD8a\0\xD36`\x04a\t\xCEV[a\0\xEDV[\0[a\0\xD8a\0\xE86`\x04a\n\x90V[a\x01\x17V[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x14V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xBFV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x83V[`@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\x83\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B8V[`@Q\x7Fa{\xA07\0\0\0\0\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`$\x82\x01\x87\x90R\x85\x81\x16`D\x83\x01R_`d\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\x90ca{\xA07\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\xCCW__\xFD[PZ\xF1\x15\x80\x15a\x02\xDEW=__>=_\xFD[PP`@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\x86\x81\x16`\x04\x83\x01R_\x93P\x7F\0\0\0\0\0\0\0\0\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\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03nW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x92\x91\x90a\x0B8V[\x90P\x81\x81\x11a\x03\xE8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x03\xF3\x83\x83a\x0B|V[\x84Q\x90\x91P\x81\x10\x15a\x04GW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xDFV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05}\x90\x85\x90\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\x90`\x84\x01[`@\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~V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1B\x91\x90a\x0B8V[a\x06%\x91\x90a\x0B\x95V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05}\x90\x85\x90\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\x90`d\x01a\x05\x19V[_a\x06\xDF\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\x07t\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07oW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFD\x91\x90a\x0B\xA8V[a\x07oW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[PPPV[``a\x07\x82\x84\x84_\x85a\x07\x8CV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\x04W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08hW`@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\x03\xDFV[__\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\x08\x90\x91\x90a\x0B\xC7V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xCAW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xCFV[``\x91P[P\x91P\x91Pa\x08\xDF\x82\x82\x86a\x08\xEAV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xF9WP\x81a\x07\x85V[\x82Q\x15a\t\tW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xDF\x91\x90a\x0B\xDDV[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\tDW__\xFD[PV[\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\x97Wa\t\x97a\tGV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC6Wa\t\xC6a\tGV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE1W__\xFD[\x845a\t\xEC\x81a\t#V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x03\x81a\t#V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x1EW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n.W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nHWa\nHa\tGV[a\n[` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9DV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\noW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA4W__\xFD[\x855a\n\xAF\x81a\t#V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC6\x81a\t#V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF7W__\xFD[Pa\x0B\0a\ttV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B%W__\xFD[Pa\x0B.a\ttV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BHW__\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[\x81\x81\x03\x81\x81\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[_` \x82\x84\x03\x12\x15a\x0B\xB8W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x85W__\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\xFE\xA2dipfsX\"\x12 \x82\xCFY\x81d\x94k\x8Fq\x9CM\x82\xEF^\xF6\x0E=\xDAW\xBE\xC7=\xE3\xE8\x87\xB6ny\x0B\xF7WqdsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r 8\x03\x80a\r \x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CJa\0\xD6_9_\x81\x81`S\x01R\x81\x81a\x03u\x01Ra\x03\xF5\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0CJ_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cF\"l1\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xF2#L\xF9\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\t\xD0V[a\0\xEDV[\0[a\0\xB1a\0\xC16`\x04a\n\x92V[a\x01\x17V[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[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 \x0F\x90\x04\x05\x04;C\xAF,\x7Fu,\xFE\x8C\xA7\xFF\xD73Q\x1A\x05>\x1A>\x8A\xD4\xB3\0\x13\x98\0$dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 g\xE5\xF4yU\x0BP|6\xA4MB`\x91\xFD\x98\xCFh\xAD\xE8lC\xBEx<\xDD\xDE\x02\xE0~\xF3(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\0\xFBW_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\x93W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x01\xBBW\x80c\xF9\xCE\x0EZ\x14a\x01\xC3W\x80c\xFAv&\xD4\x14a\x01\xD6W\x80c\xFC\x0CTj\x14a\x01\xE3W__\xFD[\x80c\x91j\x17\xC6\x14a\x01~W\x80c\xB0FO\xDC\x14a\x01\x93W\x80c\xB5P\x8A\xA9\x14a\x01\x9BW\x80c\xBAAO\xA6\x14a\x01\xA3W__\xFD[\x80c?r\x86\xF4\x11a\0\xCEW\x80c?r\x86\xF4\x14a\x01DW\x80cB\xB0\x1C\xFE\x14a\x01LW\x80cf\xD9\xA9\xA0\x14a\x01TW\x80c\x85\"l\x81\x14a\x01iW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x1E\xD7\x83\x1C\x14a\x01\tW\x80c*\xDE8\x80\x14a\x01'W\x80c>^<#\x14a\x01*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x10\xA7V[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\0W\x83\x82\x90_R` _ \x01\x80Ta\x03u\x90a\x17?V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xA1\x90a\x17?V[\x80\x15a\x03\xECW\x80`\x1F\x10a\x03\xC3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xECV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xCFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03XV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xFAV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[_sT\x1F\xD7IA\x9C\xA8\x06\xA8\xBC}\xA8\xAC#\xD3F\xF2\xDF\x8Bw\x90P_s\xCC\tf\xD8A\x8DA,Y\x9Ad!\xB7`\xA8G\xEB\x16\x9A\x8C\x90P_sI\xB0r\x15\x85d\xDB60E\x18\xFF\xA3{\x1C\xFC\x13\x91j\x90s\xBAF\xFC\xC1kFM\x97\x871Ag\xBD\xD9\xF1\xCE(@[\xA1\x7FVdR\x02@\xA4kK>\x96U\xC2\x0C\xC3\xF9\xE0\x84\x96\xA9\xB7F\xA4x\xE4v\xAE>\x04\xD6\xC8\xFC1\x7Fh\x99\xA7\xE1;e_\xA3g \x8C\xB2|n\xAA$\x107\r\x15e\xDC\x1F_\x11\x85:\x1E\x8C\xBE\xF03\x86\x86`@Qa\x05\xA1\x90a\x13\x80V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x96\x87\x16\x81R\x94\x86\x16` \x86\x01R`@\x85\x01\x93\x90\x93R``\x84\x01\x91\x90\x91R\x83\x16`\x80\x83\x01R\x90\x91\x16`\xA0\x82\x01R`\xC0\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x05\xFEW=__>=_\xFD[P\x90P_s.e\0\xA7\xAD\xD9\xA7\x88u:\x89~N4w\xF6Q\xC6\x12\xEB\x90P_s5\xB3\xF1\xBF\xE7\xCB\xE1\xE9Z=\xC2\xAD\x05N\xB6\xF0\xD4\xC8y\xB6\x90P_\x82\x82`@Qa\x06@\x90a\x13\x8DV[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x06}W=__>=_\xFD[P\x90P_\x84\x82`@Qa\x06\x8F\x90a\x13\x9AV[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x06\xCCW=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07FW__\xFD[PZ\xF1\x15\x80\x15a\x07XW=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x07\xDBW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xFF\x91\x90a\x17\x90V[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\x81R`\x01`\x04\x82\x01Ra\x08\x97\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\x08mW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\x91\x91\x90a\x17\xB6V[_a\x12\xFDV[`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t*W__\xFD[PZ\xF1\x15\x80\x15a\t=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t\x99W__\xFD[PZ\xF1\x15\x80\x15a\t\xABW=__>=_\xFD[PP`@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\x81R`\x01`\x04\x82\x01Ra\nN\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\n\x1CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n@\x91\x90a\x17\xB6V[g\r\xE0\xB6\xB3\xA7d\0\0a\x12\xFDV[PPPPPPPV[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\n\xAA\x90a\x17?V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n\xD6\x90a\x17?V[\x80\x15a\x0B!W\x80`\x1F\x10a\n\xF8Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B!V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\x04W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x0B\xB8W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0BeW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\nzV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\x0C\x10\x90a\x17?V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C<\x90a\x17?V[\x80\x15a\x0C\x87W\x80`\x1F\x10a\x0C^Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C\x87V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0CjW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0B\xF3V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\x86W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r3W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xBEV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0E\x89W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0E6W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\r\xC1V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\x0E\xE1\x90a\x17?V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F\r\x90a\x17?V[\x80\x15a\x0FXW\x80`\x1F\x10a\x0F/Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0FXV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F;W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0E\xC4V[`\x08T_\x90`\xFF\x16\x15a\x0F\x83WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\x11W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x105\x91\x90a\x17\xB6V[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11BW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x11i\x91\x90\x81\x01\x90a\x17\xFAV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x11\x87\x92\x91\x90a\x18\xAEV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11\xA3W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\xC7\x91\x90a\x17\xB6V[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12@W__\xFD[PZ\xF1\x15\x80\x15a\x12RW=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x12\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xF6\x91\x90a\x17\x90V[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x13fW__\xFD[PZ\xFA\x15\x80\x15a\x13xW=__>=_\xFD[PPPPPPV[a\x0F-\x80a\x18\xD0\x839\x01\x90V[a\r\x1E\x80a'\xFD\x839\x01\x90V[a\r \x80a5\x1B\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x13\xF4W\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\x13\xC0V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x15W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x14\xFBW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x14\xE5\x84\x86Qa\x13\xFFV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x14\xABV[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x14SV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x15sW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x153V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x15W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x15\xC9`@\x88\x01\x82a\x13\xFFV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x15\xE4\x81\x83a\x15!V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\xA3V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x15W`?\x19\x87\x86\x03\x01\x84Ra\x16=\x85\x83Qa\x13\xFFV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16!V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x15W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x16\xC0`@\x87\x01\x82a\x15!V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16xV[\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\x16\xF9W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x17\x11W__\xFD[\x845\x93Pa\x17!` \x86\x01a\x16\xD6V[\x92Pa\x17/`@\x86\x01a\x16\xD6V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x17SW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x17\x8AW\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17\xA0W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x17\xAFW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x17\xC6W__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x18\nW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18 W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x180W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18JWa\x18Ja\x17\xCDV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x18zWa\x18za\x17\xCDV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x18\x91W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x18\xC0`@\x83\x01\x85a\x13\xFFV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFEa\x01@`@R4\x80\x15a\0\x10W__\xFD[P`@Qa\x0F-8\x03\x80a\x0F-\x839\x81\x01`@\x81\x90Ra\0/\x91a\0sV[`\x01`\x01`\xA0\x1B\x03\x95\x86\x16`\x80R\x93\x85\x16`\xA0R`\xC0\x92\x90\x92R`\xE0R\x82\x16a\x01\0R\x16a\x01 Ra\0\xE3V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0pW__\xFD[PV[______`\xC0\x87\x89\x03\x12\x15a\0\x88W__\xFD[\x86Qa\0\x93\x81a\0\\V[` \x88\x01Q\x90\x96Pa\0\xA4\x81a\0\\V[`@\x88\x01Q``\x89\x01Q`\x80\x8A\x01Q\x92\x97P\x90\x95P\x93Pa\0\xC4\x81a\0\\V[`\xA0\x88\x01Q\x90\x92Pa\0\xD5\x81a\0\\V[\x80\x91PP\x92\x95P\x92\x95P\x92\x95V[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\r\xC6a\x01g_9_\x81\x81a\x01.\x01R\x81\x81a\x04\xFC\x01Ra\x05>\x01R_\x81\x81a\x01U\x01Ra\x03R\x01R_\x81\x81a\x01\xB1\x01Ra\x03\xC1\x01R_\x81\x81a\x01|\x01Ra\x02\x88\x01R_\x81\x81`\xDF\x01R\x81\x81a\x03t\x01Ra\x03\xF0\x01R_\x81\x81`\x8E\x01R\x81\x81a\x02;\x01Ra\x02\xB7\x01Ra\r\xC6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\x85W_5`\xE0\x1C\x80c\xADt}\xE6\x11a\0XW\x80c\xADt}\xE6\x14a\x01)W\x80c\xB9\x93|\xCB\x14a\x01PW\x80c\xC8\xC7\xF7\x01\x14a\x01wW\x80c\xE3L\xEF\x86\x14a\x01\xACW__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0\x89W\x80cN=\xF3\xF4\x14a\0\xDAW\x80cPcL\x0E\x14a\x01\x01W\x80c\x7F\x81O5\x14a\x01\x16W[__\xFD[a\0\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\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\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\x81V[a\x01\x14a\x01\x0F6`\x04a\x0BgV[a\x01\xD3V[\0[a\x01\x14a\x01$6`\x04a\x0C)V[a\x01\xFDV[a\0\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\x81V[a\0\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\x81V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xD1V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\xE8\x91\x90a\x0C\xADV[\x90Pa\x01\xF6\x85\x85\x85\x84a\x01\xFDV[PPPPPV[a\x02\x1Fs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x9AV[a\x02`s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x036\x91\x90a\x0C\xD1V[\x90Pa\x03\x99s\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\x7F\0\0\0\0\0\0\0\0\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\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x82\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04KW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04o\x91\x90a\x0C\xD1V[\x83Q\x90\x91P\x81\x10\x15a\x04\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[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\x85\x83a\x07YV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x06X\x90\x85\x90\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\x90`\x84\x01[`@\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\x07\xB4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF6\x91\x90a\x0C\xD1V[a\x07\0\x91\x90a\x0C\xE8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x06X\x90\x85\x90\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\x90`d\x01a\x05\xF4V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07\xAF\x90\x84\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\x90`d\x01a\x05\xF4V[PPPV[_a\x08\x15\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\x08\xBF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\xAFW\x80\x80` \x01\x90Q\x81\x01\x90a\x083\x91\x90a\r&V[a\x07\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\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\x04\xD9V[``a\x08\xCD\x84\x84_\x85a\x08\xD7V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\tiW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x04\xD9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\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`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x04\xD9V[__\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\n\x0F\x91\x90a\rEV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\nIW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\nNV[``\x91P[P\x91P\x91Pa\n^\x82\x82\x86a\niV[\x97\x96PPPPPPPV[``\x83\x15a\nxWP\x81a\x08\xD0V[\x82Q\x15a\n\x88W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x04\xD9\x91\x90a\r[V[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\xDDW__\xFD[PV[\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\x0B0Wa\x0B0a\n\xE0V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0B_Wa\x0B_a\n\xE0V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0BzW__\xFD[\x845a\x0B\x85\x81a\n\xBCV[\x93P` \x85\x015\x92P`@\x85\x015a\x0B\x9C\x81a\n\xBCV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xB7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\x0B\xC7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xE1Wa\x0B\xE1a\n\xE0V[a\x0B\xF4` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0B6V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0C\x08W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0C=W__\xFD[\x855a\x0CH\x81a\n\xBCV[\x94P` \x86\x015\x93P`@\x86\x015a\x0C_\x81a\n\xBCV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0C\x90W__\xFD[Pa\x0C\x99a\x0B\rV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0C\xBEW__\xFD[Pa\x0C\xC7a\x0B\rV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C\xE1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\r 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[_` \x82\x84\x03\x12\x15a\r6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x08\xD0W__\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\xFE\xA2dipfsX\"\x12 \xD28\x8C\xB3\xDCz\xA6\xF5\xA2\xEBuA}\x11\x05\x9B\xE1<\x8C\x9E\xAB\xE5\xD7\xEA\xDB\x1BV\x1F\x93\x7F\xF6\x91dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\x1E8\x03\x80a\r\x1E\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CHa\0\xD6_9_\x81\x81`S\x01R\x81\x81a\x01U\x01Ra\x02\x89\x01R_\x81\x81`\xA3\x01R\x81\x81a\x01\xC1\x01R\x81\x81a\x03(\x01Ra\x04b\x01Ra\x0CH_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x16\xF0\x11[\x14a\0NW\x80c%\xE2\xD6%\x14a\0\x9EW\x80cPcL\x0E\x14a\0\xC5W\x80c\x7F\x81O5\x14a\0\xDAW[__\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\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[a\0\xD8a\0\xD36`\x04a\t\xCEV[a\0\xEDV[\0[a\0\xD8a\0\xE86`\x04a\n\x90V[a\x01\x17V[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x14V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xBFV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x83V[`@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\x83\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B8V[`@Q\x7Fa{\xA07\0\0\0\0\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`$\x82\x01\x87\x90R\x85\x81\x16`D\x83\x01R_`d\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\x90ca{\xA07\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\xCCW__\xFD[PZ\xF1\x15\x80\x15a\x02\xDEW=__>=_\xFD[PP`@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\x86\x81\x16`\x04\x83\x01R_\x93P\x7F\0\0\0\0\0\0\0\0\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\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03nW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x92\x91\x90a\x0B8V[\x90P\x81\x81\x11a\x03\xE8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x03\xF3\x83\x83a\x0B|V[\x84Q\x90\x91P\x81\x10\x15a\x04GW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xDFV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05}\x90\x85\x90\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\x90`\x84\x01[`@\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~V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1B\x91\x90a\x0B8V[a\x06%\x91\x90a\x0B\x95V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05}\x90\x85\x90\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\x90`d\x01a\x05\x19V[_a\x06\xDF\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\x07t\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07oW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFD\x91\x90a\x0B\xA8V[a\x07oW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[PPPV[``a\x07\x82\x84\x84_\x85a\x07\x8CV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\x04W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08hW`@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\x03\xDFV[__\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\x08\x90\x91\x90a\x0B\xC7V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xCAW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xCFV[``\x91P[P\x91P\x91Pa\x08\xDF\x82\x82\x86a\x08\xEAV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xF9WP\x81a\x07\x85V[\x82Q\x15a\t\tW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xDF\x91\x90a\x0B\xDDV[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\tDW__\xFD[PV[\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\x97Wa\t\x97a\tGV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC6Wa\t\xC6a\tGV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE1W__\xFD[\x845a\t\xEC\x81a\t#V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x03\x81a\t#V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x1EW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n.W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nHWa\nHa\tGV[a\n[` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9DV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\noW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA4W__\xFD[\x855a\n\xAF\x81a\t#V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC6\x81a\t#V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF7W__\xFD[Pa\x0B\0a\ttV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B%W__\xFD[Pa\x0B.a\ttV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BHW__\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[\x81\x81\x03\x81\x81\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[_` \x82\x84\x03\x12\x15a\x0B\xB8W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x85W__\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\xFE\xA2dipfsX\"\x12 \x82\xCFY\x81d\x94k\x8Fq\x9CM\x82\xEF^\xF6\x0E=\xDAW\xBE\xC7=\xE3\xE8\x87\xB6ny\x0B\xF7WqdsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r 8\x03\x80a\r \x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CJa\0\xD6_9_\x81\x81`S\x01R\x81\x81a\x03u\x01Ra\x03\xF5\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0CJ_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cF\"l1\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xF2#L\xF9\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\t\xD0V[a\0\xEDV[\0[a\0\xB1a\0\xC16`\x04a\n\x92V[a\x01\x17V[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[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 \x0F\x90\x04\x05\x04;C\xAF,\x7Fu,\xFE\x8C\xA7\xFF\xD73Q\x1A\x05>\x1A>\x8A\xD4\xB3\0\x13\x98\0$dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 g\xE5\xF4yU\x0BP|6\xA4MB`\x91\xFD\x98\xCFh\xAD\xE8lC\xBEx<\xDD\xDE\x02\xE0~\xF3(dsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. +```solidity +event log(string); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log { + type DataTuple<'a> = (alloy::sol_types::sol_data::String,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log(string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, + 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, + 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. +```solidity +event log_address(address); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_address { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_address { + type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_address(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, + 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, + 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_address { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_address> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_address) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. +```solidity +event log_array(uint256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_0 { + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_0 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(uint256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, + 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, + 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_0 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_0> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. +```solidity +event log_array(int256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_1 { + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_1 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(int256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, + 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, + 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_1 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_1> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. +```solidity +event log_array(address[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_2 { + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_2 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(address[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, + 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, + 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_2 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_2> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. +```solidity +event log_bytes(bytes); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_bytes { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_bytes { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_bytes(bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, + 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, + 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_bytes { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_bytes> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. +```solidity +event log_bytes32(bytes32); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_bytes32 { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_bytes32 { + type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_bytes32(bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, + 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, + 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_bytes32 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_bytes32> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. +```solidity +event log_int(int256); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_int { + #[allow(missing_docs)] + pub _0: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_int { + type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_int(int256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, + 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, + 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. +```solidity +event log_named_address(string key, address val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_address { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_address { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Address, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_address(string,address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, + 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, + 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_address { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_address> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. +```solidity +event log_named_array(string key, uint256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_0 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_0 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, + 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, + 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_0 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_0> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. +```solidity +event log_named_array(string key, int256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_1 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_1 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,int256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, + 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, + 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_1 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_1> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. +```solidity +event log_named_array(string key, address[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_2 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_2 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,address[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, + 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, + 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_2 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_2> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. +```solidity +event log_named_bytes(string key, bytes val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_bytes { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_bytes { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Bytes, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, + 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, + 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_bytes { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_bytes> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. +```solidity +event log_named_bytes32(string key, bytes32 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_bytes32 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_bytes32 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::FixedBytes<32>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, + 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, + 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_bytes32 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. +```solidity +event log_named_decimal_int(string key, int256 val, uint256 decimals); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_decimal_int { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::I256, + #[allow(missing_docs)] + pub decimals: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_decimal_int { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Int<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, + 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, + 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + key: data.0, + val: data.1, + decimals: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + as alloy_sol_types::SolType>::tokenize(&self.decimals), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_decimal_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. +```solidity +event log_named_decimal_uint(string key, uint256 val, uint256 decimals); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_decimal_uint { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub decimals: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_decimal_uint { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, + 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, + 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + key: data.0, + val: data.1, + decimals: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + as alloy_sol_types::SolType>::tokenize(&self.decimals), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. +```solidity +event log_named_int(string key, int256 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_int { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_int { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Int<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_int(string,int256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, + 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, + 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. +```solidity +event log_named_string(string key, string val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_string { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::String, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_string { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::String, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_string(string,string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, + 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, + 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_string { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_string> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. +```solidity +event log_named_uint(string key, uint256 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_uint { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_uint { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, + 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, + 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. +```solidity +event log_string(string); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_string { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_string { + type DataTuple<'a> = (alloy::sol_types::sol_data::String,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_string(string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, + 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, + 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_string { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_string> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_string) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. +```solidity +event log_uint(uint256); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_uint { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_uint { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_uint(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, + 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, + 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. +```solidity +event logs(bytes); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct logs { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for logs { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "logs(bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, + 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, + 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 logs { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&logs> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &logs) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. +```solidity +function IS_TEST() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IS_TESTCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IS_TESTReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IS_TESTCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IS_TESTCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IS_TESTReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IS_TESTReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for IS_TESTCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "IS_TEST()"; + const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: IS_TESTReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: IS_TESTReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. +```solidity +function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeArtifactsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeArtifactsReturn { + #[allow(missing_docs)] + pub excludedArtifacts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeArtifactsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeArtifactsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeArtifactsReturn) -> Self { + (value.excludedArtifacts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeArtifactsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedArtifacts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeArtifactsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeArtifacts()"; + const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeArtifactsReturn = r.into(); + r.excludedArtifacts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeArtifactsReturn = r.into(); + r.excludedArtifacts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. +```solidity +function excludeContracts() external view returns (address[] memory excludedContracts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeContractsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeContractsReturn { + #[allow(missing_docs)] + pub excludedContracts_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeContractsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeContractsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeContractsReturn) -> Self { + (value.excludedContracts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeContractsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedContracts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeContractsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeContracts()"; + const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeContractsReturn = r.into(); + r.excludedContracts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeContractsReturn = r.into(); + r.excludedContracts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. +```solidity +function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSelectorsReturn { + #[allow(missing_docs)] + pub excludedSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSelectorsReturn) -> Self { + (value.excludedSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeSelectors()"; + const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeSelectorsReturn = r.into(); + r.excludedSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeSelectorsReturn = r.into(); + r.excludedSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. +```solidity +function excludeSenders() external view returns (address[] memory excludedSenders_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSendersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSendersReturn { + #[allow(missing_docs)] + pub excludedSenders_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: excludeSendersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for excludeSendersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSendersReturn) -> Self { + (value.excludedSenders_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSendersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { excludedSenders_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeSendersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeSenders()"; + const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeSendersReturn = r.into(); + r.excludedSenders_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeSendersReturn = r.into(); + r.excludedSenders_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `failed()` and selector `0xba414fa6`. +```solidity +function failed() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct failedCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`failed()`](failedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct failedReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: failedCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for failedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: failedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for failedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for failedCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "failed()"; + const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: failedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: failedReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `setUp()` and selector `0x0a9254e4`. +```solidity +function setUp() external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setUpCall; + ///Container type for the return parameters of the [`setUp()`](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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setUpCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setUpReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setUpReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setUpCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setUpReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setUp()"; + const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setUpReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. +```solidity +function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct simulateForkAndTransferCall { + #[allow(missing_docs)] + pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub sender: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct simulateForkAndTransferReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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::Uint<256>, + ); + #[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::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferCall) -> Self { + (value.forkAtBlock, value.sender, value.receiver, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for simulateForkAndTransferCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + forkAtBlock: tuple.0, + sender: tuple.1, + receiver: tuple.2, + amount: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for simulateForkAndTransferReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl simulateForkAndTransferReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for simulateForkAndTransferCall { + type Parameters<'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::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = simulateForkAndTransferReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; + const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), + ::tokenize( + &self.sender, + ), + ::tokenize( + &self.receiver, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + simulateForkAndTransferReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. +```solidity +function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactSelectorsReturn { + #[allow(missing_docs)] + pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactSelectorsReturn) -> Self { + (value.targetedArtifactSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedArtifactSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetArtifactSelectors()"; + const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetArtifacts()` and selector `0x85226c81`. +```solidity +function targetArtifacts() external view returns (string[] memory targetedArtifacts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactsReturn { + #[allow(missing_docs)] + pub targetedArtifacts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetArtifactsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsReturn) -> Self { + (value.targetedArtifacts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedArtifacts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetArtifactsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetArtifacts()"; + const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetContracts()` and selector `0x3f7286f4`. +```solidity +function targetContracts() external view returns (address[] memory targetedContracts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetContractsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetContractsReturn { + #[allow(missing_docs)] + pub targetedContracts_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetContractsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetContractsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetContractsReturn) -> Self { + (value.targetedContracts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetContractsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedContracts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetContractsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetContracts()"; + const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetContractsReturn = r.into(); + r.targetedContracts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetContractsReturn = r.into(); + r.targetedContracts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. +```solidity +function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetInterfacesCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetInterfacesReturn { + #[allow(missing_docs)] + pub targetedInterfaces_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetInterfacesCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetInterfacesCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetInterfacesReturn) -> Self { + (value.targetedInterfaces_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetInterfacesReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedInterfaces_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetInterfacesCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetInterfaces()"; + const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetSelectors()` and selector `0x916a17c6`. +```solidity +function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSelectorsReturn { + #[allow(missing_docs)] + pub targetedSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetSelectorsReturn) -> Self { + (value.targetedSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetSelectors()"; + const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. +```solidity +function targetSenders() external view returns (address[] memory targetedSenders_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSendersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSendersReturn { + #[allow(missing_docs)] + pub targetedSenders_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSendersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersReturn) -> Self { + (value.targetedSenders_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSendersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { targetedSenders_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetSendersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetSenders()"; + const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetSendersReturn = r.into(); + r.targetedSenders_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetSendersReturn = r.into(); + r.targetedSenders_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `testWbtcLstStrategy()` and selector `0x42b01cfe`. +```solidity +function testWbtcLstStrategy() external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct testWbtcLstStrategyCall; + ///Container type for the return parameters of the [`testWbtcLstStrategy()`](testWbtcLstStrategyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct testWbtcLstStrategyReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: testWbtcLstStrategyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for testWbtcLstStrategyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: testWbtcLstStrategyReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for testWbtcLstStrategyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl testWbtcLstStrategyReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for testWbtcLstStrategyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = testWbtcLstStrategyReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "testWbtcLstStrategy()"; + const SELECTOR: [u8; 4] = [66u8, 176u8, 28u8, 254u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + testWbtcLstStrategyReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `token()` and selector `0xfc0c546a`. +```solidity +function token() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct tokenCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`token()`](tokenCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct tokenReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for tokenCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for tokenReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for tokenCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "token()"; + const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`AvalonWBTCLstStrategyForked`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum AvalonWBTCLstStrategyForkedCalls { + #[allow(missing_docs)] + IS_TEST(IS_TESTCall), + #[allow(missing_docs)] + excludeArtifacts(excludeArtifactsCall), + #[allow(missing_docs)] + excludeContracts(excludeContractsCall), + #[allow(missing_docs)] + excludeSelectors(excludeSelectorsCall), + #[allow(missing_docs)] + excludeSenders(excludeSendersCall), + #[allow(missing_docs)] + failed(failedCall), + #[allow(missing_docs)] + setUp(setUpCall), + #[allow(missing_docs)] + simulateForkAndTransfer(simulateForkAndTransferCall), + #[allow(missing_docs)] + targetArtifactSelectors(targetArtifactSelectorsCall), + #[allow(missing_docs)] + targetArtifacts(targetArtifactsCall), + #[allow(missing_docs)] + targetContracts(targetContractsCall), + #[allow(missing_docs)] + targetInterfaces(targetInterfacesCall), + #[allow(missing_docs)] + targetSelectors(targetSelectorsCall), + #[allow(missing_docs)] + targetSenders(targetSendersCall), + #[allow(missing_docs)] + testWbtcLstStrategy(testWbtcLstStrategyCall), + #[allow(missing_docs)] + token(tokenCall), + } + #[automatically_derived] + impl AvalonWBTCLstStrategyForkedCalls { + /// 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]] = &[ + [10u8, 146u8, 84u8, 228u8], + [30u8, 215u8, 131u8, 28u8], + [42u8, 222u8, 56u8, 128u8], + [62u8, 94u8, 60u8, 35u8], + [63u8, 114u8, 134u8, 244u8], + [66u8, 176u8, 28u8, 254u8], + [102u8, 217u8, 169u8, 160u8], + [133u8, 34u8, 108u8, 129u8], + [145u8, 106u8, 23u8, 198u8], + [176u8, 70u8, 79u8, 220u8], + [181u8, 80u8, 138u8, 169u8], + [186u8, 65u8, 79u8, 166u8], + [226u8, 12u8, 159u8, 113u8], + [249u8, 206u8, 14u8, 90u8], + [250u8, 118u8, 38u8, 212u8], + [252u8, 12u8, 84u8, 106u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for AvalonWBTCLstStrategyForkedCalls { + const NAME: &'static str = "AvalonWBTCLstStrategyForkedCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 16usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::IS_TEST(_) => ::SELECTOR, + Self::excludeArtifacts(_) => { + ::SELECTOR + } + Self::excludeContracts(_) => { + ::SELECTOR + } + Self::excludeSelectors(_) => { + ::SELECTOR + } + Self::excludeSenders(_) => { + ::SELECTOR + } + Self::failed(_) => ::SELECTOR, + Self::setUp(_) => ::SELECTOR, + Self::simulateForkAndTransfer(_) => { + ::SELECTOR + } + Self::targetArtifactSelectors(_) => { + ::SELECTOR + } + Self::targetArtifacts(_) => { + ::SELECTOR + } + Self::targetContracts(_) => { + ::SELECTOR + } + Self::targetInterfaces(_) => { + ::SELECTOR + } + Self::targetSelectors(_) => { + ::SELECTOR + } + Self::targetSenders(_) => { + ::SELECTOR + } + Self::testWbtcLstStrategy(_) => { + ::SELECTOR + } + Self::token(_) => ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn setUp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(AvalonWBTCLstStrategyForkedCalls::setUp) + } + setUp + }, + { + fn excludeSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::excludeSenders) + } + excludeSenders + }, + { + fn targetInterfaces( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::targetInterfaces) + } + targetInterfaces + }, + { + fn targetSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::targetSenders) + } + targetSenders + }, + { + fn targetContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::targetContracts) + } + targetContracts + }, + { + fn testWbtcLstStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::testWbtcLstStrategy) + } + testWbtcLstStrategy + }, + { + fn targetArtifactSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + AvalonWBTCLstStrategyForkedCalls::targetArtifactSelectors, + ) + } + targetArtifactSelectors + }, + { + fn targetArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::targetArtifacts) + } + targetArtifacts + }, + { + fn targetSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::targetSelectors) + } + targetSelectors + }, + { + fn excludeSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::excludeSelectors) + } + excludeSelectors + }, + { + fn excludeArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::excludeArtifacts) + } + excludeArtifacts + }, + { + fn failed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(AvalonWBTCLstStrategyForkedCalls::failed) + } + failed + }, + { + fn excludeContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::excludeContracts) + } + excludeContracts + }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + AvalonWBTCLstStrategyForkedCalls::simulateForkAndTransfer, + ) + } + simulateForkAndTransfer + }, + { + fn IS_TEST( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(AvalonWBTCLstStrategyForkedCalls::IS_TEST) + } + IS_TEST + }, + { + fn token( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(AvalonWBTCLstStrategyForkedCalls::token) + } + token + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn setUp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::setUp) + } + setUp + }, + { + fn excludeSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::excludeSenders) + } + excludeSenders + }, + { + fn targetInterfaces( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::targetInterfaces) + } + targetInterfaces + }, + { + fn targetSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::targetSenders) + } + targetSenders + }, + { + fn targetContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::targetContracts) + } + targetContracts + }, + { + fn testWbtcLstStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::testWbtcLstStrategy) + } + testWbtcLstStrategy + }, + { + fn targetArtifactSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + AvalonWBTCLstStrategyForkedCalls::targetArtifactSelectors, + ) + } + targetArtifactSelectors + }, + { + fn targetArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::targetArtifacts) + } + targetArtifacts + }, + { + fn targetSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::targetSelectors) + } + targetSelectors + }, + { + fn excludeSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::excludeSelectors) + } + excludeSelectors + }, + { + fn excludeArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::excludeArtifacts) + } + excludeArtifacts + }, + { + fn failed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::failed) + } + failed + }, + { + fn excludeContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::excludeContracts) + } + excludeContracts + }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + AvalonWBTCLstStrategyForkedCalls::simulateForkAndTransfer, + ) + } + simulateForkAndTransfer + }, + { + fn IS_TEST( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::IS_TEST) + } + IS_TEST + }, + { + fn token( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(AvalonWBTCLstStrategyForkedCalls::token) + } + token + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::IS_TEST(inner) => { + ::abi_encoded_size(inner) + } + Self::excludeArtifacts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeContracts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeSenders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::failed(inner) => { + ::abi_encoded_size(inner) + } + Self::setUp(inner) => { + ::abi_encoded_size(inner) + } + Self::simulateForkAndTransfer(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetArtifactSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetArtifacts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetContracts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetInterfaces(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetSenders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::testWbtcLstStrategy(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::token(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::IS_TEST(inner) => { + ::abi_encode_raw(inner, out) + } + Self::excludeArtifacts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeContracts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeSenders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::failed(inner) => { + ::abi_encode_raw(inner, out) + } + Self::setUp(inner) => { + ::abi_encode_raw(inner, out) + } + Self::simulateForkAndTransfer(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetArtifactSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetArtifacts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetContracts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetInterfaces(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetSenders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::testWbtcLstStrategy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::token(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + ///Container for all the [`AvalonWBTCLstStrategyForked`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum AvalonWBTCLstStrategyForkedEvents { + #[allow(missing_docs)] + log(log), + #[allow(missing_docs)] + log_address(log_address), + #[allow(missing_docs)] + log_array_0(log_array_0), + #[allow(missing_docs)] + log_array_1(log_array_1), + #[allow(missing_docs)] + log_array_2(log_array_2), + #[allow(missing_docs)] + log_bytes(log_bytes), + #[allow(missing_docs)] + log_bytes32(log_bytes32), + #[allow(missing_docs)] + log_int(log_int), + #[allow(missing_docs)] + log_named_address(log_named_address), + #[allow(missing_docs)] + log_named_array_0(log_named_array_0), + #[allow(missing_docs)] + log_named_array_1(log_named_array_1), + #[allow(missing_docs)] + log_named_array_2(log_named_array_2), + #[allow(missing_docs)] + log_named_bytes(log_named_bytes), + #[allow(missing_docs)] + log_named_bytes32(log_named_bytes32), + #[allow(missing_docs)] + log_named_decimal_int(log_named_decimal_int), + #[allow(missing_docs)] + log_named_decimal_uint(log_named_decimal_uint), + #[allow(missing_docs)] + log_named_int(log_named_int), + #[allow(missing_docs)] + log_named_string(log_named_string), + #[allow(missing_docs)] + log_named_uint(log_named_uint), + #[allow(missing_docs)] + log_string(log_string), + #[allow(missing_docs)] + log_uint(log_uint), + #[allow(missing_docs)] + logs(logs), + } + #[automatically_derived] + impl AvalonWBTCLstStrategyForkedEvents { + /// 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]] = &[ + [ + 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, + 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, + 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, + ], + [ + 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, + 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, + 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, + ], + [ + 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, + 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, + 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, + ], + [ + 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, + 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, + 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, + ], + [ + 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, + 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, + 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, + ], + [ + 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, + 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, + 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, + ], + [ + 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, + 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, + 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, + ], + [ + 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, + 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, + 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, + ], + [ + 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, + 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, + 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, + ], + [ + 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, + 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, + 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, + ], + [ + 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, + 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, + 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, + ], + [ + 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, + 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, + 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, + ], + [ + 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, + 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, + 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, + ], + [ + 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, + 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, + 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, + ], + [ + 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, + 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, + 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, + ], + [ + 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, + 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, + 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, + ], + [ + 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, + 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, + 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, + ], + [ + 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, + 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, + 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, + ], + [ + 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, + 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, + 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, + ], + [ + 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, + 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, + 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, + ], + [ + 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, + 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, + 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, + ], + [ + 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, + 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, + 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for AvalonWBTCLstStrategyForkedEvents { + const NAME: &'static str = "AvalonWBTCLstStrategyForkedEvents"; + const COUNT: usize = 22usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_address) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_0) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_1) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_2) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_bytes) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_bytes32) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log_int) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_address) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_0) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_1) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_2) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_bytes) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_bytes32) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_decimal_int) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_decimal_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_int) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_string) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_string) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::logs) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 AvalonWBTCLstStrategyForkedEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::log(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_address(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_0(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_1(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_2(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_bytes(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_address(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_0(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_1(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_2(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_bytes(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_decimal_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_decimal_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_string(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_string(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::logs(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::log(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_address(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_0(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_1(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_2(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_bytes(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_address(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_0(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_1(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_2(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_bytes(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_decimal_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_decimal_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_string(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_string(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::logs(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`AvalonWBTCLstStrategyForked`](self) contract instance. + +See the [wrapper's documentation](`AvalonWBTCLstStrategyForkedInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> AvalonWBTCLstStrategyForkedInstance { + AvalonWBTCLstStrategyForkedInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + AvalonWBTCLstStrategyForkedInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + AvalonWBTCLstStrategyForkedInstance::::deploy_builder(provider) + } + /**A [`AvalonWBTCLstStrategyForked`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`AvalonWBTCLstStrategyForked`](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 AvalonWBTCLstStrategyForkedInstance< + P, + N = alloy_contract::private::Ethereum, + > { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for AvalonWBTCLstStrategyForkedInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("AvalonWBTCLstStrategyForkedInstance") + .field(&self.address) + .finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > AvalonWBTCLstStrategyForkedInstance { + /**Creates a new wrapper around an on-chain [`AvalonWBTCLstStrategyForked`](self) contract instance. + +See the [wrapper's documentation](`AvalonWBTCLstStrategyForkedInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 AvalonWBTCLstStrategyForkedInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> AvalonWBTCLstStrategyForkedInstance { + AvalonWBTCLstStrategyForkedInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > AvalonWBTCLstStrategyForkedInstance { + /// 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( + &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 [`IS_TEST`] function. + pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { + self.call_builder(&IS_TESTCall) + } + ///Creates a new call builder for the [`excludeArtifacts`] function. + pub fn excludeArtifacts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { + self.call_builder(&excludeArtifactsCall) + } + ///Creates a new call builder for the [`excludeContracts`] function. + pub fn excludeContracts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { + self.call_builder(&excludeContractsCall) + } + ///Creates a new call builder for the [`excludeSelectors`] function. + pub fn excludeSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { + self.call_builder(&excludeSelectorsCall) + } + ///Creates a new call builder for the [`excludeSenders`] function. + pub fn excludeSenders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { + self.call_builder(&excludeSendersCall) + } + ///Creates a new call builder for the [`failed`] function. + pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { + self.call_builder(&failedCall) + } + ///Creates a new call builder for the [`setUp`] function. + pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { + self.call_builder(&setUpCall) + } + ///Creates a new call builder for the [`simulateForkAndTransfer`] function. + pub fn simulateForkAndTransfer( + &self, + forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + sender: alloy::sol_types::private::Address, + receiver: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { + self.call_builder( + &simulateForkAndTransferCall { + forkAtBlock, + sender, + receiver, + amount, + }, + ) + } + ///Creates a new call builder for the [`targetArtifactSelectors`] function. + pub fn targetArtifactSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { + self.call_builder(&targetArtifactSelectorsCall) + } + ///Creates a new call builder for the [`targetArtifacts`] function. + pub fn targetArtifacts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { + self.call_builder(&targetArtifactsCall) + } + ///Creates a new call builder for the [`targetContracts`] function. + pub fn targetContracts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { + self.call_builder(&targetContractsCall) + } + ///Creates a new call builder for the [`targetInterfaces`] function. + pub fn targetInterfaces( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { + self.call_builder(&targetInterfacesCall) + } + ///Creates a new call builder for the [`targetSelectors`] function. + pub fn targetSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { + self.call_builder(&targetSelectorsCall) + } + ///Creates a new call builder for the [`targetSenders`] function. + pub fn targetSenders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { + self.call_builder(&targetSendersCall) + } + ///Creates a new call builder for the [`testWbtcLstStrategy`] function. + pub fn testWbtcLstStrategy( + &self, + ) -> alloy_contract::SolCallBuilder<&P, testWbtcLstStrategyCall, N> { + self.call_builder(&testWbtcLstStrategyCall) + } + ///Creates a new call builder for the [`token`] function. + pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { + self.call_builder(&tokenCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > AvalonWBTCLstStrategyForkedInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`log`] event. + pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_address`] event. + pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_0`] event. + pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_1`] event. + pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_2`] event. + pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_bytes`] event. + pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_bytes32`] event. + pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_int`] event. + pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_address`] event. + pub fn log_named_address_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_address, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_0`] event. + pub fn log_named_array_0_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_0, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_1`] event. + pub fn log_named_array_1_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_1, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_2`] event. + pub fn log_named_array_2_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_2, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_bytes`] event. + pub fn log_named_bytes_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_bytes, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_bytes32`] event. + pub fn log_named_bytes32_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_bytes32, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_decimal_int`] event. + pub fn log_named_decimal_int_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_decimal_uint`] event. + pub fn log_named_decimal_uint_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_int`] event. + pub fn log_named_int_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_string`] event. + pub fn log_named_string_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_string, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_uint`] event. + pub fn log_named_uint_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_string`] event. + pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_uint`] event. + pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`logs`] event. + pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/bedrock_strategy.rs b/crates/bindings/src/bedrock_strategy.rs new file mode 100644 index 000000000..34d69d8fc --- /dev/null +++ b/crates/bindings/src/bedrock_strategy.rs @@ -0,0 +1,1554 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface BedrockStrategy { + struct StrategySlippageArgs { + uint256 amountOutMin; + } + + event TokenOutput(address tokenReceived, uint256 amountOut); + + constructor(address _vault); + + function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; + function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; + function vault() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_vault", + "type": "address", + "internalType": "contract IBedrockVault" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessage", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "message", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessageWithSlippageArgs", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "args", + "type": "tuple", + "internalType": "struct StrategySlippageArgs", + "components": [ + { + "name": "amountOutMin", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "vault", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IBedrockVault" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "TokenOutput", + "inputs": [ + { + "name": "tokenReceived", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "amountOut", + "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 BedrockStrategy { + use super::*; + use alloy::sol_types as 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__\xFD[P`@Qa\x0C\xD48\x03\x80a\x0C\xD4\x839\x81\x01`@\x81\x90Ra\0.\x91a\0?V[`\x01`\x01`\xA0\x1B\x03\x16`\x80Ra\0lV[_` \x82\x84\x03\x12\x15a\0OW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0eW__\xFD[\x93\x92PPPV[`\x80Qa\x0C=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02UW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02y\x91\x90a\x0B,V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xE6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\n\x91\x90a\x0BGV[\x83Q\x90\x91P\x81\x10\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\x9Es\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x85\x83a\x05\xB4V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xB3\x90\x85\x90\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\x90`\x84\x01[`@\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\x0FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05-W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05Q\x91\x90a\x0BGV[a\x05[\x91\x90a\x0B^V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xB3\x90\x85\x90\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\x90`d\x01a\x04OV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x06\n\x90\x84\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\x90`d\x01a\x04OV[PPPV[_a\x06p\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\x07\x1A\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\nW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x8E\x91\x90a\x0B\x9CV[a\x06\nW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[``a\x07(\x84\x84_\x85a\x072V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xC4W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08BW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[__\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\x08j\x91\x90a\x0B\xBBV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xA4W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xA9V[``\x91P[P\x91P\x91Pa\x08\xB9\x82\x82\x86a\x08\xC4V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xD3WP\x81a\x07+V[\x82Q\x15a\x08\xE3W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03t\x91\x90a\x0B\xD1V[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\t8W__\xFD[PV[\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\x8BWa\t\x8Ba\t;V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xBAWa\t\xBAa\t;V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xD5W__\xFD[\x845a\t\xE0\x81a\t\x17V[\x93P` \x85\x015\x92P`@\x85\x015a\t\xF7\x81a\t\x17V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x12W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\"W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nz9,\xA4\xD4K\x0C\x1B\x8D=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02UW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02y\x91\x90a\x0B,V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xE6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\n\x91\x90a\x0BGV[\x83Q\x90\x91P\x81\x10\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\x9Es\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x85\x83a\x05\xB4V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xB3\x90\x85\x90\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\x90`\x84\x01[`@\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\x0FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05-W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05Q\x91\x90a\x0BGV[a\x05[\x91\x90a\x0B^V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xB3\x90\x85\x90\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\x90`d\x01a\x04OV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x06\n\x90\x84\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\x90`d\x01a\x04OV[PPPV[_a\x06p\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\x07\x1A\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\nW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x8E\x91\x90a\x0B\x9CV[a\x06\nW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[``a\x07(\x84\x84_\x85a\x072V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xC4W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08BW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[__\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\x08j\x91\x90a\x0B\xBBV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xA4W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xA9V[``\x91P[P\x91P\x91Pa\x08\xB9\x82\x82\x86a\x08\xC4V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xD3WP\x81a\x07+V[\x82Q\x15a\x08\xE3W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03t\x91\x90a\x0B\xD1V[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\t8W__\xFD[PV[\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\x8BWa\t\x8Ba\t;V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xBAWa\t\xBAa\t;V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xD5W__\xFD[\x845a\t\xE0\x81a\t\x17V[\x93P` \x85\x015\x92P`@\x85\x015a\t\xF7\x81a\t\x17V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x12W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\"W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nz9,\xA4\xD4K\x0C\x1B\x8D = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: StrategySlippageArgs) -> Self { + (value.amountOutMin,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for StrategySlippageArgs { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { amountOutMin: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for StrategySlippageArgs { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for StrategySlippageArgs { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for StrategySlippageArgs { + const NAME: &'static str = "StrategySlippageArgs"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "StrategySlippageArgs(uint256 amountOutMin)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) + .0 + .to_vec() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for StrategySlippageArgs { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.amountOutMin, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.amountOutMin, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. +```solidity +event TokenOutput(address tokenReceived, uint256 amountOut); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct TokenOutput { + #[allow(missing_docs)] + pub tokenReceived: alloy::sol_types::private::Address, + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for TokenOutput { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + tokenReceived: data.0, + amountOut: data.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.tokenReceived, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountOut), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 TokenOutput { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&TokenOutput> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &TokenOutput) -> 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._vault,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._vault, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. +```solidity +function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub message: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ); + #[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, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.message) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + message: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageCall { + 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, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; + const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.message, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. +```solidity +function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub args: ::RustType, + } + ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Address, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.args) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + args: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageWithSlippageArgsReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageWithSlippageArgsReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; + const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.args, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: vaultCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for vaultCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: vaultReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for vaultReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for vaultCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "vault()"; + const SELECTOR: [u8; 4] = [251u8, 250u8, 119u8, 207u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: vaultReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`BedrockStrategy`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum BedrockStrategyCalls { + #[allow(missing_docs)] + handleGatewayMessage(handleGatewayMessageCall), + #[allow(missing_docs)] + handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), + #[allow(missing_docs)] + vault(vaultCall), + } + #[automatically_derived] + impl BedrockStrategyCalls { + /// 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, 99u8, 76u8, 14u8], + [127u8, 129u8, 79u8, 53u8], + [251u8, 250u8, 119u8, 207u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for BedrockStrategyCalls { + const NAME: &'static str = "BedrockStrategyCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 3usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::handleGatewayMessage(_) => { + ::SELECTOR + } + Self::handleGatewayMessageWithSlippageArgs(_) => { + ::SELECTOR + } + Self::vault(_) => ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BedrockStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + BedrockStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + { + fn vault( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(BedrockStrategyCalls::vault) + } + vault + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BedrockStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + BedrockStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + { + fn vault( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BedrockStrategyCalls::vault) + } + vault + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::handleGatewayMessage(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::vault(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::handleGatewayMessage(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::vault(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + ///Container for all the [`BedrockStrategy`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum BedrockStrategyEvents { + #[allow(missing_docs)] + TokenOutput(TokenOutput), + } + #[automatically_derived] + impl BedrockStrategyEvents { + /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for BedrockStrategyEvents { + const NAME: &'static str = "BedrockStrategyEvents"; + const COUNT: usize = 1usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::TokenOutput) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 BedrockStrategyEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`BedrockStrategy`](self) contract instance. + +See the [wrapper's documentation](`BedrockStrategyInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> BedrockStrategyInstance { + BedrockStrategyInstance::::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: alloy_contract::private::Network, + >( + provider: P, + _vault: alloy::sol_types::private::Address, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + BedrockStrategyInstance::::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: alloy_contract::private::Network, + >( + provider: P, + _vault: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + BedrockStrategyInstance::::deploy_builder(provider, _vault) + } + /**A [`BedrockStrategy`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`BedrockStrategy`](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 BedrockStrategyInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for BedrockStrategyInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("BedrockStrategyInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BedrockStrategyInstance { + /**Creates a new wrapper around an on-chain [`BedrockStrategy`](self) contract instance. + +See the [wrapper's documentation](`BedrockStrategyInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 BedrockStrategyInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> BedrockStrategyInstance { + BedrockStrategyInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BedrockStrategyInstance { + /// 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( + &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 [`handleGatewayMessage`] function. + pub fn handleGatewayMessage( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + message: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { + self.call_builder( + &handleGatewayMessageCall { + tokenSent, + amountIn, + recipient, + message, + }, + ) + } + ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. + pub fn handleGatewayMessageWithSlippageArgs( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + args: ::RustType, + ) -> alloy_contract::SolCallBuilder< + &P, + handleGatewayMessageWithSlippageArgsCall, + N, + > { + self.call_builder( + &handleGatewayMessageWithSlippageArgsCall { + tokenSent, + amountIn, + recipient, + args, + }, + ) + } + ///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. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BedrockStrategyInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`TokenOutput`] event. + pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/bedrock_strategy_forked.rs b/crates/bindings/src/bedrock_strategy_forked.rs new file mode 100644 index 000000000..6f0498b39 --- /dev/null +++ b/crates/bindings/src/bedrock_strategy_forked.rs @@ -0,0 +1,7991 @@ +///Module containing a contract's types and functions. +/** + +```solidity +library StdInvariant { + struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } + struct FuzzInterface { address addr; string[] artifacts; } + struct FuzzSelector { address addr; bytes4[] selectors; } +} +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod StdInvariant { + use super::*; + use alloy::sol_types as alloy_sol_types; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzArtifactSelector { + #[allow(missing_docs)] + pub artifact: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub selectors: alloy::sol_types::private::Vec< + 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 as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::String, + alloy::sol_types::private::Vec>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzArtifactSelector) -> Self { + (value.artifact, value.selectors) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzArtifactSelector { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + artifact: tuple.0, + selectors: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzArtifactSelector { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.artifact, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.selectors), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzArtifactSelector { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzArtifactSelector { + const NAME: &'static str = "FuzzArtifactSelector"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzArtifactSelector(string artifact,bytes4[] selectors)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.artifact, + ) + .0, + , + > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzArtifactSelector { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.artifact, + ) + + , + > as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.selectors, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.artifact, + out, + ); + , + > as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.selectors, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzInterface { address addr; string[] artifacts; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzInterface { + #[allow(missing_docs)] + pub addr: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub artifacts: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzInterface) -> Self { + (value.addr, value.artifacts) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzInterface { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + addr: tuple.0, + artifacts: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzInterface { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzInterface { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.addr, + ), + as alloy_sol_types::SolType>::tokenize(&self.artifacts), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzInterface { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzInterface { + const NAME: &'static str = "FuzzInterface"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzInterface(address addr,string[] artifacts)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.addr, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzInterface { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.addr, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.artifacts, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.addr, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.artifacts, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzSelector { address addr; bytes4[] selectors; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzSelector { + #[allow(missing_docs)] + pub addr: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub selectors: alloy::sol_types::private::Vec< + 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 as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Vec>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzSelector) -> Self { + (value.addr, value.selectors) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzSelector { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + addr: tuple.0, + selectors: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzSelector { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzSelector { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.addr, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.selectors), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzSelector { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzSelector { + const NAME: &'static str = "FuzzSelector"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzSelector(address addr,bytes4[] selectors)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.addr, + ) + .0, + , + > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzSelector { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.addr, + ) + + , + > as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.selectors, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.addr, + out, + ); + , + > as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.selectors, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. + +See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> StdInvariantInstance { + StdInvariantInstance::::new(address, provider) + } + /**A [`StdInvariant`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`StdInvariant`](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 StdInvariantInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for StdInvariantInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("StdInvariantInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. + +See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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 StdInvariantInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> StdInvariantInstance { + StdInvariantInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} +/** + +Generated by the following Solidity interface... +```solidity +library StdInvariant { + struct FuzzArtifactSelector { + string artifact; + bytes4[] selectors; + } + struct FuzzInterface { + address addr; + string[] artifacts; + } + struct FuzzSelector { + address addr; + bytes4[] selectors; + } +} + +interface BedrockStrategyForked { + event log(string); + event log_address(address); + event log_array(uint256[] val); + event log_array(int256[] val); + event log_array(address[] val); + event log_bytes(bytes); + event log_bytes32(bytes32); + event log_int(int256); + event log_named_address(string key, address val); + event log_named_array(string key, uint256[] val); + event log_named_array(string key, int256[] val); + event log_named_array(string key, address[] val); + event log_named_bytes(string key, bytes val); + event log_named_bytes32(string key, bytes32 val); + event log_named_decimal_int(string key, int256 val, uint256 decimals); + event log_named_decimal_uint(string key, uint256 val, uint256 decimals); + event log_named_int(string key, int256 val); + event log_named_string(string key, string val); + event log_named_uint(string key, uint256 val); + event log_string(string); + event log_uint(uint256); + event logs(bytes); + + function IS_TEST() external view returns (bool); + function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); + function excludeContracts() external view returns (address[] memory excludedContracts_); + function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); + function excludeSenders() external view returns (address[] memory excludedSenders_); + function failed() external view returns (bool); + function setUp() external; + function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; + function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); + function targetArtifacts() external view returns (string[] memory targetedArtifacts_); + function targetContracts() external view returns (address[] memory targetedContracts_); + function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); + function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); + function targetSenders() external view returns (address[] memory targetedSenders_); + function testBedrockStrategy() external; + function token() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "IS_TEST", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeArtifacts", + "inputs": [], + "outputs": [ + { + "name": "excludedArtifacts_", + "type": "string[]", + "internalType": "string[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeContracts", + "inputs": [], + "outputs": [ + { + "name": "excludedContracts_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeSelectors", + "inputs": [], + "outputs": [ + { + "name": "excludedSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzSelector[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeSenders", + "inputs": [], + "outputs": [ + { + "name": "excludedSenders_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "failed", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "setUp", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "simulateForkAndTransfer", + "inputs": [ + { + "name": "forkAtBlock", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "sender", + "type": "address", + "internalType": "address" + }, + { + "name": "receiver", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "targetArtifactSelectors", + "inputs": [], + "outputs": [ + { + "name": "targetedArtifactSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzArtifactSelector[]", + "components": [ + { + "name": "artifact", + "type": "string", + "internalType": "string" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetArtifacts", + "inputs": [], + "outputs": [ + { + "name": "targetedArtifacts_", + "type": "string[]", + "internalType": "string[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetContracts", + "inputs": [], + "outputs": [ + { + "name": "targetedContracts_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetInterfaces", + "inputs": [], + "outputs": [ + { + "name": "targetedInterfaces_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzInterface[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "artifacts", + "type": "string[]", + "internalType": "string[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetSelectors", + "inputs": [], + "outputs": [ + { + "name": "targetedSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzSelector[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetSenders", + "inputs": [], + "outputs": [ + { + "name": "targetedSenders_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "testBedrockStrategy", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "token", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IERC20" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "log", + "inputs": [ + { + "name": "", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_address", + "inputs": [ + { + "name": "", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "uint256[]", + "indexed": false, + "internalType": "uint256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "int256[]", + "indexed": false, + "internalType": "int256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "address[]", + "indexed": false, + "internalType": "address[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_bytes", + "inputs": [ + { + "name": "", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_bytes32", + "inputs": [ + { + "name": "", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_int", + "inputs": [ + { + "name": "", + "type": "int256", + "indexed": false, + "internalType": "int256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_address", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256[]", + "indexed": false, + "internalType": "uint256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256[]", + "indexed": false, + "internalType": "int256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "address[]", + "indexed": false, + "internalType": "address[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_bytes", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_bytes32", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_decimal_int", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256", + "indexed": false, + "internalType": "int256" + }, + { + "name": "decimals", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_decimal_uint", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "decimals", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_int", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256", + "indexed": false, + "internalType": "int256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_string", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_uint", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_string", + "inputs": [ + { + "name": "", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_uint", + "inputs": [ + { + "name": "", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "logs", + "inputs": [ + { + "name": "", + "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 BedrockStrategyForked { + use super::*; + use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15`+W__\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16t\x03\xC7\x05K\xCB9\xF7\xB2\xE5\xB2\xC7\xAC\xB3u\x83\xE3-p\xCF\xA3\0\x17\x90Ua$\x91\x80a\0a_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xFBW_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\x93W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x01\xBBW\x80c\xF9\xCE\x0EZ\x14a\x01\xC3W\x80c\xFAv&\xD4\x14a\x01\xD6W\x80c\xFC\x0CTj\x14a\x01\xE3W__\xFD[\x80c\x91j\x17\xC6\x14a\x01~W\x80c\xB0FO\xDC\x14a\x01\x93W\x80c\xB5P\x8A\xA9\x14a\x01\x9BW\x80c\xBAAO\xA6\x14a\x01\xA3W__\xFD[\x80c>^<#\x11a\0\xCEW\x80c>^<#\x14a\x01DW\x80c?r\x86\xF4\x14a\x01LW\x80cf\xD9\xA9\xA0\x14a\x01TW\x80c\x85\"l\x81\x14a\x01iW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x1E\xD7\x83\x1C\x14a\x01\tW\x80c*\xDE8\x80\x14a\x01'W\x80c=\x81'\xE0\x14a\x01*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x0F5V[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\0W\x83\x82\x90_R` _ \x01\x80Ta\x03u\x90a\x15\xB5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xA1\x90a\x15\xB5V[\x80\x15a\x03\xECW\x80`\x1F\x10a\x03\xC3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xECV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xCFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03XV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xFAV[PPPP\x90P\x90V[_s*\xC9\x8D\xB4\x1C\xBD1r\xCB{\x8F\xD8\xA8\xAB;\x91\xCF\xE4]\xCF\x90P_\x81`@Qa\x04F\x90a\x12\x10V[s\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_\xF0\x80\x15\x80\x15a\x04|W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xF6W__\xFD[PZ\xF1\x15\x80\x15a\x05\x08W=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x05\x8BW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xAF\x91\x90a\x16\x06V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x06CW__\xFD[PZ\xF1\x15\x80\x15a\x06UW=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x06\xB2W__\xFD[PZ\xF1\x15\x80\x15a\x06\xC4W=__>=_\xFD[PPPP_\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x076\x91\x90a\x16,V[`@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\x81R`\x01`\x04\x82\x01R\x90\x91Pa\x08\n\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07\xA6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xCA\x91\x90a\x16GV[c\x05\xF5\xE1\0`@Q\x80`@\x01`@R\x80`\x1C\x81R` \x01\x7FUser uniBTC balance mismatch\0\0\0\0\x81RPa\x11\x8BV[PPPV[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\t8\x90a\x15\xB5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\td\x90a\x15\xB5V[\x80\x15a\t\xAFW\x80`\x1F\x10a\t\x86Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\t\xAFV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t\x92W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\nFW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\t\xF3W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\t\x08V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\n\x9E\x90a\x15\xB5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n\xCA\x90a\x15\xB5V[\x80\x15a\x0B\x15W\x80`\x1F\x10a\n\xECWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\x15V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\n\xF8W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\n\x81V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\x14W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0B\xC1W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0BLV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\x17W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C\xC4W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0COV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\ro\x90a\x15\xB5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\x9B\x90a\x15\xB5V[\x80\x15a\r\xE6W\x80`\x1F\x10a\r\xBDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\r\xE6V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r\xC9W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\rRV[`\x08T_\x90`\xFF\x16\x15a\x0E\x11WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\xC3\x91\x90a\x16GV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\xD0W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x0F\xF7\x91\x90\x81\x01\x90a\x16\x8BV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x10\x15\x92\x91\x90a\x17?V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x101W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10U\x91\x90a\x16GV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10\xCEW__\xFD[PZ\xF1\x15\x80\x15a\x10\xE0W=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11`W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\x84\x91\x90a\x16\x06V[PPPPPV[`@Q\x7F\x88\xB4L\x85\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x88\xB4L\x85\x90a\x11\xDF\x90\x86\x90\x86\x90\x86\x90`\x04\x01a\x17`V[_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x11\xF5W__\xFD[PZ\xFA\x15\x80\x15a\x12\x07W=__>=_\xFD[PPPPPPPV[a\x0C\xD4\x80a\x17\x88\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x12jW\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\x126V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x8BW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x13qW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x13[\x84\x86Qa\x12uV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x13!V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x12\xC9V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x13\xE9W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x13\xA9V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x8BW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x14?`@\x88\x01\x82a\x12uV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x14Z\x81\x83a\x13\x97V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\x19V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x8BW`?\x19\x87\x86\x03\x01\x84Ra\x14\xB3\x85\x83Qa\x12uV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\x97V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x8BW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x156`@\x87\x01\x82a\x13\x97V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\xEEV[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\x15mW__\xFD[PV[____`\x80\x85\x87\x03\x12\x15a\x15\x83W__\xFD[\x845\x93P` \x85\x015a\x15\x95\x81a\x15LV[\x92P`@\x85\x015a\x15\xA5\x81a\x15LV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x15\xC9W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x16\0W\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x16\x16W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x16%W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x16=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02UW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02y\x91\x90a\x0B,V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xE6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\n\x91\x90a\x0BGV[\x83Q\x90\x91P\x81\x10\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\x9Es\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x85\x83a\x05\xB4V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xB3\x90\x85\x90\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\x90`\x84\x01[`@\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\x0FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05-W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05Q\x91\x90a\x0BGV[a\x05[\x91\x90a\x0B^V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xB3\x90\x85\x90\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\x90`d\x01a\x04OV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x06\n\x90\x84\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\x90`d\x01a\x04OV[PPPV[_a\x06p\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\x07\x1A\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\nW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x8E\x91\x90a\x0B\x9CV[a\x06\nW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[``a\x07(\x84\x84_\x85a\x072V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xC4W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08BW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[__\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\x08j\x91\x90a\x0B\xBBV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xA4W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xA9V[``\x91P[P\x91P\x91Pa\x08\xB9\x82\x82\x86a\x08\xC4V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xD3WP\x81a\x07+V[\x82Q\x15a\x08\xE3W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03t\x91\x90a\x0B\xD1V[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\t8W__\xFD[PV[\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\x8BWa\t\x8Ba\t;V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xBAWa\t\xBAa\t;V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xD5W__\xFD[\x845a\t\xE0\x81a\t\x17V[\x93P` \x85\x015\x92P`@\x85\x015a\t\xF7\x81a\t\x17V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x12W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\"W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nz9,\xA4\xD4K\x0C\x1B\x8D^<#\x11a\0\xCEW\x80c>^<#\x14a\x01DW\x80c?r\x86\xF4\x14a\x01LW\x80cf\xD9\xA9\xA0\x14a\x01TW\x80c\x85\"l\x81\x14a\x01iW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x1E\xD7\x83\x1C\x14a\x01\tW\x80c*\xDE8\x80\x14a\x01'W\x80c=\x81'\xE0\x14a\x01*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x0F5V[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\0W\x83\x82\x90_R` _ \x01\x80Ta\x03u\x90a\x15\xB5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xA1\x90a\x15\xB5V[\x80\x15a\x03\xECW\x80`\x1F\x10a\x03\xC3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xECV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xCFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03XV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xFAV[PPPP\x90P\x90V[_s*\xC9\x8D\xB4\x1C\xBD1r\xCB{\x8F\xD8\xA8\xAB;\x91\xCF\xE4]\xCF\x90P_\x81`@Qa\x04F\x90a\x12\x10V[s\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_\xF0\x80\x15\x80\x15a\x04|W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xF6W__\xFD[PZ\xF1\x15\x80\x15a\x05\x08W=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x05\x8BW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xAF\x91\x90a\x16\x06V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x06CW__\xFD[PZ\xF1\x15\x80\x15a\x06UW=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x06\xB2W__\xFD[PZ\xF1\x15\x80\x15a\x06\xC4W=__>=_\xFD[PPPP_\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x076\x91\x90a\x16,V[`@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\x81R`\x01`\x04\x82\x01R\x90\x91Pa\x08\n\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07\xA6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xCA\x91\x90a\x16GV[c\x05\xF5\xE1\0`@Q\x80`@\x01`@R\x80`\x1C\x81R` \x01\x7FUser uniBTC balance mismatch\0\0\0\0\x81RPa\x11\x8BV[PPPV[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\t8\x90a\x15\xB5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\td\x90a\x15\xB5V[\x80\x15a\t\xAFW\x80`\x1F\x10a\t\x86Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\t\xAFV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t\x92W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\nFW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\t\xF3W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\t\x08V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\n\x9E\x90a\x15\xB5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n\xCA\x90a\x15\xB5V[\x80\x15a\x0B\x15W\x80`\x1F\x10a\n\xECWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\x15V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\n\xF8W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\n\x81V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\x14W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0B\xC1W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0BLV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\x17W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C\xC4W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0COV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\ro\x90a\x15\xB5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\x9B\x90a\x15\xB5V[\x80\x15a\r\xE6W\x80`\x1F\x10a\r\xBDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\r\xE6V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r\xC9W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\rRV[`\x08T_\x90`\xFF\x16\x15a\x0E\x11WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\xC3\x91\x90a\x16GV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\xD0W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x0F\xF7\x91\x90\x81\x01\x90a\x16\x8BV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x10\x15\x92\x91\x90a\x17?V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x101W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10U\x91\x90a\x16GV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10\xCEW__\xFD[PZ\xF1\x15\x80\x15a\x10\xE0W=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11`W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\x84\x91\x90a\x16\x06V[PPPPPV[`@Q\x7F\x88\xB4L\x85\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x88\xB4L\x85\x90a\x11\xDF\x90\x86\x90\x86\x90\x86\x90`\x04\x01a\x17`V[_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x11\xF5W__\xFD[PZ\xFA\x15\x80\x15a\x12\x07W=__>=_\xFD[PPPPPPPV[a\x0C\xD4\x80a\x17\x88\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x12jW\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\x126V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x8BW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x13qW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x13[\x84\x86Qa\x12uV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x13!V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x12\xC9V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x13\xE9W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x13\xA9V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x8BW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x14?`@\x88\x01\x82a\x12uV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x14Z\x81\x83a\x13\x97V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\x19V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x8BW`?\x19\x87\x86\x03\x01\x84Ra\x14\xB3\x85\x83Qa\x12uV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\x97V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x8BW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x156`@\x87\x01\x82a\x13\x97V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\xEEV[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\x15mW__\xFD[PV[____`\x80\x85\x87\x03\x12\x15a\x15\x83W__\xFD[\x845\x93P` \x85\x015a\x15\x95\x81a\x15LV[\x92P`@\x85\x015a\x15\xA5\x81a\x15LV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x15\xC9W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x16\0W\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x16\x16W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x16%W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x16=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02UW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02y\x91\x90a\x0B,V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xE6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\n\x91\x90a\x0BGV[\x83Q\x90\x91P\x81\x10\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\x9Es\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x85\x83a\x05\xB4V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xB3\x90\x85\x90\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\x90`\x84\x01[`@\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\x0FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05-W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05Q\x91\x90a\x0BGV[a\x05[\x91\x90a\x0B^V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xB3\x90\x85\x90\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\x90`d\x01a\x04OV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x06\n\x90\x84\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\x90`d\x01a\x04OV[PPPV[_a\x06p\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\x07\x1A\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\nW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x8E\x91\x90a\x0B\x9CV[a\x06\nW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[``a\x07(\x84\x84_\x85a\x072V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xC4W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08BW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[__\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\x08j\x91\x90a\x0B\xBBV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xA4W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xA9V[``\x91P[P\x91P\x91Pa\x08\xB9\x82\x82\x86a\x08\xC4V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xD3WP\x81a\x07+V[\x82Q\x15a\x08\xE3W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03t\x91\x90a\x0B\xD1V[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\t8W__\xFD[PV[\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\x8BWa\t\x8Ba\t;V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xBAWa\t\xBAa\t;V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xD5W__\xFD[\x845a\t\xE0\x81a\t\x17V[\x93P` \x85\x015\x92P`@\x85\x015a\t\xF7\x81a\t\x17V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x12W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\"W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nz9,\xA4\xD4K\x0C\x1B\x8D = (alloy::sol_types::sol_data::String,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log(string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, + 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, + 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. +```solidity +event log_address(address); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_address { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_address { + type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_address(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, + 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, + 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_address { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_address> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_address) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. +```solidity +event log_array(uint256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_0 { + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_0 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(uint256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, + 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, + 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_0 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_0> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. +```solidity +event log_array(int256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_1 { + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_1 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(int256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, + 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, + 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_1 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_1> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. +```solidity +event log_array(address[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_2 { + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_2 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(address[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, + 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, + 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_2 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_2> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. +```solidity +event log_bytes(bytes); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_bytes { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_bytes { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_bytes(bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, + 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, + 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_bytes { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_bytes> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. +```solidity +event log_bytes32(bytes32); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_bytes32 { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_bytes32 { + type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_bytes32(bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, + 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, + 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_bytes32 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_bytes32> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. +```solidity +event log_int(int256); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_int { + #[allow(missing_docs)] + pub _0: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_int { + type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_int(int256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, + 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, + 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. +```solidity +event log_named_address(string key, address val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_address { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_address { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Address, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_address(string,address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, + 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, + 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_address { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_address> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. +```solidity +event log_named_array(string key, uint256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_0 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_0 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, + 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, + 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_0 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_0> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. +```solidity +event log_named_array(string key, int256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_1 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_1 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,int256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, + 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, + 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_1 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_1> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. +```solidity +event log_named_array(string key, address[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_2 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_2 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,address[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, + 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, + 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_2 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_2> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. +```solidity +event log_named_bytes(string key, bytes val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_bytes { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_bytes { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Bytes, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, + 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, + 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_bytes { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_bytes> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. +```solidity +event log_named_bytes32(string key, bytes32 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_bytes32 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_bytes32 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::FixedBytes<32>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, + 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, + 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_bytes32 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. +```solidity +event log_named_decimal_int(string key, int256 val, uint256 decimals); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_decimal_int { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::I256, + #[allow(missing_docs)] + pub decimals: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_decimal_int { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Int<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, + 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, + 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + key: data.0, + val: data.1, + decimals: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + as alloy_sol_types::SolType>::tokenize(&self.decimals), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_decimal_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. +```solidity +event log_named_decimal_uint(string key, uint256 val, uint256 decimals); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_decimal_uint { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub decimals: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_decimal_uint { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, + 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, + 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + key: data.0, + val: data.1, + decimals: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + as alloy_sol_types::SolType>::tokenize(&self.decimals), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. +```solidity +event log_named_int(string key, int256 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_int { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_int { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Int<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_int(string,int256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, + 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, + 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. +```solidity +event log_named_string(string key, string val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_string { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::String, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_string { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::String, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_string(string,string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, + 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, + 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_string { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_string> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. +```solidity +event log_named_uint(string key, uint256 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_uint { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_uint { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, + 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, + 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. +```solidity +event log_string(string); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_string { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_string { + type DataTuple<'a> = (alloy::sol_types::sol_data::String,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_string(string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, + 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, + 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_string { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_string> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_string) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. +```solidity +event log_uint(uint256); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_uint { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_uint { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_uint(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, + 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, + 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. +```solidity +event logs(bytes); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct logs { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for logs { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "logs(bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, + 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, + 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 logs { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&logs> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &logs) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. +```solidity +function IS_TEST() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IS_TESTCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IS_TESTReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IS_TESTCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IS_TESTCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IS_TESTReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IS_TESTReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for IS_TESTCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "IS_TEST()"; + const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: IS_TESTReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: IS_TESTReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. +```solidity +function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeArtifactsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeArtifactsReturn { + #[allow(missing_docs)] + pub excludedArtifacts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeArtifactsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeArtifactsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeArtifactsReturn) -> Self { + (value.excludedArtifacts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeArtifactsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedArtifacts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeArtifactsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeArtifacts()"; + const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeArtifactsReturn = r.into(); + r.excludedArtifacts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeArtifactsReturn = r.into(); + r.excludedArtifacts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. +```solidity +function excludeContracts() external view returns (address[] memory excludedContracts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeContractsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeContractsReturn { + #[allow(missing_docs)] + pub excludedContracts_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeContractsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeContractsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeContractsReturn) -> Self { + (value.excludedContracts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeContractsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedContracts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeContractsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeContracts()"; + const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeContractsReturn = r.into(); + r.excludedContracts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeContractsReturn = r.into(); + r.excludedContracts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. +```solidity +function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSelectorsReturn { + #[allow(missing_docs)] + pub excludedSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSelectorsReturn) -> Self { + (value.excludedSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeSelectors()"; + const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeSelectorsReturn = r.into(); + r.excludedSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeSelectorsReturn = r.into(); + r.excludedSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. +```solidity +function excludeSenders() external view returns (address[] memory excludedSenders_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSendersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSendersReturn { + #[allow(missing_docs)] + pub excludedSenders_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: excludeSendersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for excludeSendersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSendersReturn) -> Self { + (value.excludedSenders_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSendersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { excludedSenders_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeSendersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeSenders()"; + const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeSendersReturn = r.into(); + r.excludedSenders_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeSendersReturn = r.into(); + r.excludedSenders_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `failed()` and selector `0xba414fa6`. +```solidity +function failed() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct failedCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`failed()`](failedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct failedReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: failedCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for failedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: failedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for failedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for failedCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "failed()"; + const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: failedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: failedReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `setUp()` and selector `0x0a9254e4`. +```solidity +function setUp() external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setUpCall; + ///Container type for the return parameters of the [`setUp()`](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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setUpCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setUpReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setUpReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setUpCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setUpReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setUp()"; + const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setUpReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. +```solidity +function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct simulateForkAndTransferCall { + #[allow(missing_docs)] + pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub sender: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct simulateForkAndTransferReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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::Uint<256>, + ); + #[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::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferCall) -> Self { + (value.forkAtBlock, value.sender, value.receiver, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for simulateForkAndTransferCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + forkAtBlock: tuple.0, + sender: tuple.1, + receiver: tuple.2, + amount: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for simulateForkAndTransferReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl simulateForkAndTransferReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for simulateForkAndTransferCall { + type Parameters<'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::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = simulateForkAndTransferReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; + const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), + ::tokenize( + &self.sender, + ), + ::tokenize( + &self.receiver, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + simulateForkAndTransferReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. +```solidity +function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactSelectorsReturn { + #[allow(missing_docs)] + pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactSelectorsReturn) -> Self { + (value.targetedArtifactSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedArtifactSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetArtifactSelectors()"; + const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetArtifacts()` and selector `0x85226c81`. +```solidity +function targetArtifacts() external view returns (string[] memory targetedArtifacts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactsReturn { + #[allow(missing_docs)] + pub targetedArtifacts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetArtifactsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsReturn) -> Self { + (value.targetedArtifacts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedArtifacts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetArtifactsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetArtifacts()"; + const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetContracts()` and selector `0x3f7286f4`. +```solidity +function targetContracts() external view returns (address[] memory targetedContracts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetContractsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetContractsReturn { + #[allow(missing_docs)] + pub targetedContracts_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetContractsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetContractsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetContractsReturn) -> Self { + (value.targetedContracts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetContractsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedContracts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetContractsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetContracts()"; + const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetContractsReturn = r.into(); + r.targetedContracts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetContractsReturn = r.into(); + r.targetedContracts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. +```solidity +function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetInterfacesCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetInterfacesReturn { + #[allow(missing_docs)] + pub targetedInterfaces_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetInterfacesCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetInterfacesCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetInterfacesReturn) -> Self { + (value.targetedInterfaces_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetInterfacesReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedInterfaces_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetInterfacesCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetInterfaces()"; + const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetSelectors()` and selector `0x916a17c6`. +```solidity +function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSelectorsReturn { + #[allow(missing_docs)] + pub targetedSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetSelectorsReturn) -> Self { + (value.targetedSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetSelectors()"; + const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. +```solidity +function targetSenders() external view returns (address[] memory targetedSenders_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSendersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSendersReturn { + #[allow(missing_docs)] + pub targetedSenders_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSendersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersReturn) -> Self { + (value.targetedSenders_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSendersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { targetedSenders_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetSendersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetSenders()"; + const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetSendersReturn = r.into(); + r.targetedSenders_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetSendersReturn = r.into(); + r.targetedSenders_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `testBedrockStrategy()` and selector `0x3d8127e0`. +```solidity +function testBedrockStrategy() external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct testBedrockStrategyCall; + ///Container type for the return parameters of the [`testBedrockStrategy()`](testBedrockStrategyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct testBedrockStrategyReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: testBedrockStrategyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for testBedrockStrategyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: testBedrockStrategyReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for testBedrockStrategyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl testBedrockStrategyReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for testBedrockStrategyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = testBedrockStrategyReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "testBedrockStrategy()"; + const SELECTOR: [u8; 4] = [61u8, 129u8, 39u8, 224u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + testBedrockStrategyReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `token()` and selector `0xfc0c546a`. +```solidity +function token() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct tokenCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`token()`](tokenCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct tokenReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for tokenCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for tokenReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for tokenCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "token()"; + const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`BedrockStrategyForked`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum BedrockStrategyForkedCalls { + #[allow(missing_docs)] + IS_TEST(IS_TESTCall), + #[allow(missing_docs)] + excludeArtifacts(excludeArtifactsCall), + #[allow(missing_docs)] + excludeContracts(excludeContractsCall), + #[allow(missing_docs)] + excludeSelectors(excludeSelectorsCall), + #[allow(missing_docs)] + excludeSenders(excludeSendersCall), + #[allow(missing_docs)] + failed(failedCall), + #[allow(missing_docs)] + setUp(setUpCall), + #[allow(missing_docs)] + simulateForkAndTransfer(simulateForkAndTransferCall), + #[allow(missing_docs)] + targetArtifactSelectors(targetArtifactSelectorsCall), + #[allow(missing_docs)] + targetArtifacts(targetArtifactsCall), + #[allow(missing_docs)] + targetContracts(targetContractsCall), + #[allow(missing_docs)] + targetInterfaces(targetInterfacesCall), + #[allow(missing_docs)] + targetSelectors(targetSelectorsCall), + #[allow(missing_docs)] + targetSenders(targetSendersCall), + #[allow(missing_docs)] + testBedrockStrategy(testBedrockStrategyCall), + #[allow(missing_docs)] + token(tokenCall), + } + #[automatically_derived] + impl BedrockStrategyForkedCalls { + /// 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]] = &[ + [10u8, 146u8, 84u8, 228u8], + [30u8, 215u8, 131u8, 28u8], + [42u8, 222u8, 56u8, 128u8], + [61u8, 129u8, 39u8, 224u8], + [62u8, 94u8, 60u8, 35u8], + [63u8, 114u8, 134u8, 244u8], + [102u8, 217u8, 169u8, 160u8], + [133u8, 34u8, 108u8, 129u8], + [145u8, 106u8, 23u8, 198u8], + [176u8, 70u8, 79u8, 220u8], + [181u8, 80u8, 138u8, 169u8], + [186u8, 65u8, 79u8, 166u8], + [226u8, 12u8, 159u8, 113u8], + [249u8, 206u8, 14u8, 90u8], + [250u8, 118u8, 38u8, 212u8], + [252u8, 12u8, 84u8, 106u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for BedrockStrategyForkedCalls { + const NAME: &'static str = "BedrockStrategyForkedCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 16usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::IS_TEST(_) => ::SELECTOR, + Self::excludeArtifacts(_) => { + ::SELECTOR + } + Self::excludeContracts(_) => { + ::SELECTOR + } + Self::excludeSelectors(_) => { + ::SELECTOR + } + Self::excludeSenders(_) => { + ::SELECTOR + } + Self::failed(_) => ::SELECTOR, + Self::setUp(_) => ::SELECTOR, + Self::simulateForkAndTransfer(_) => { + ::SELECTOR + } + Self::targetArtifactSelectors(_) => { + ::SELECTOR + } + Self::targetArtifacts(_) => { + ::SELECTOR + } + Self::targetContracts(_) => { + ::SELECTOR + } + Self::targetInterfaces(_) => { + ::SELECTOR + } + Self::targetSelectors(_) => { + ::SELECTOR + } + Self::targetSenders(_) => { + ::SELECTOR + } + Self::testBedrockStrategy(_) => { + ::SELECTOR + } + Self::token(_) => ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn setUp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(BedrockStrategyForkedCalls::setUp) + } + setUp + }, + { + fn excludeSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BedrockStrategyForkedCalls::excludeSenders) + } + excludeSenders + }, + { + fn targetInterfaces( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BedrockStrategyForkedCalls::targetInterfaces) + } + targetInterfaces + }, + { + fn testBedrockStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BedrockStrategyForkedCalls::testBedrockStrategy) + } + testBedrockStrategy + }, + { + fn targetSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BedrockStrategyForkedCalls::targetSenders) + } + targetSenders + }, + { + fn targetContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BedrockStrategyForkedCalls::targetContracts) + } + targetContracts + }, + { + fn targetArtifactSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BedrockStrategyForkedCalls::targetArtifactSelectors) + } + targetArtifactSelectors + }, + { + fn targetArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BedrockStrategyForkedCalls::targetArtifacts) + } + targetArtifacts + }, + { + fn targetSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BedrockStrategyForkedCalls::targetSelectors) + } + targetSelectors + }, + { + fn excludeSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BedrockStrategyForkedCalls::excludeSelectors) + } + excludeSelectors + }, + { + fn excludeArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BedrockStrategyForkedCalls::excludeArtifacts) + } + excludeArtifacts + }, + { + fn failed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(BedrockStrategyForkedCalls::failed) + } + failed + }, + { + fn excludeContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BedrockStrategyForkedCalls::excludeContracts) + } + excludeContracts + }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BedrockStrategyForkedCalls::simulateForkAndTransfer) + } + simulateForkAndTransfer + }, + { + fn IS_TEST( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(BedrockStrategyForkedCalls::IS_TEST) + } + IS_TEST + }, + { + fn token( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(BedrockStrategyForkedCalls::token) + } + token + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn setUp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BedrockStrategyForkedCalls::setUp) + } + setUp + }, + { + fn excludeSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BedrockStrategyForkedCalls::excludeSenders) + } + excludeSenders + }, + { + fn targetInterfaces( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BedrockStrategyForkedCalls::targetInterfaces) + } + targetInterfaces + }, + { + fn testBedrockStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BedrockStrategyForkedCalls::testBedrockStrategy) + } + testBedrockStrategy + }, + { + fn targetSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BedrockStrategyForkedCalls::targetSenders) + } + targetSenders + }, + { + fn targetContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BedrockStrategyForkedCalls::targetContracts) + } + targetContracts + }, + { + fn targetArtifactSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BedrockStrategyForkedCalls::targetArtifactSelectors) + } + targetArtifactSelectors + }, + { + fn targetArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BedrockStrategyForkedCalls::targetArtifacts) + } + targetArtifacts + }, + { + fn targetSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BedrockStrategyForkedCalls::targetSelectors) + } + targetSelectors + }, + { + fn excludeSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BedrockStrategyForkedCalls::excludeSelectors) + } + excludeSelectors + }, + { + fn excludeArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BedrockStrategyForkedCalls::excludeArtifacts) + } + excludeArtifacts + }, + { + fn failed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BedrockStrategyForkedCalls::failed) + } + failed + }, + { + fn excludeContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BedrockStrategyForkedCalls::excludeContracts) + } + excludeContracts + }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BedrockStrategyForkedCalls::simulateForkAndTransfer) + } + simulateForkAndTransfer + }, + { + fn IS_TEST( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BedrockStrategyForkedCalls::IS_TEST) + } + IS_TEST + }, + { + fn token( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BedrockStrategyForkedCalls::token) + } + token + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::IS_TEST(inner) => { + ::abi_encoded_size(inner) + } + Self::excludeArtifacts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeContracts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeSenders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::failed(inner) => { + ::abi_encoded_size(inner) + } + Self::setUp(inner) => { + ::abi_encoded_size(inner) + } + Self::simulateForkAndTransfer(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetArtifactSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetArtifacts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetContracts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetInterfaces(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetSenders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::testBedrockStrategy(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::token(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::IS_TEST(inner) => { + ::abi_encode_raw(inner, out) + } + Self::excludeArtifacts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeContracts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeSenders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::failed(inner) => { + ::abi_encode_raw(inner, out) + } + Self::setUp(inner) => { + ::abi_encode_raw(inner, out) + } + Self::simulateForkAndTransfer(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetArtifactSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetArtifacts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetContracts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetInterfaces(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetSenders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::testBedrockStrategy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::token(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + ///Container for all the [`BedrockStrategyForked`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum BedrockStrategyForkedEvents { + #[allow(missing_docs)] + log(log), + #[allow(missing_docs)] + log_address(log_address), + #[allow(missing_docs)] + log_array_0(log_array_0), + #[allow(missing_docs)] + log_array_1(log_array_1), + #[allow(missing_docs)] + log_array_2(log_array_2), + #[allow(missing_docs)] + log_bytes(log_bytes), + #[allow(missing_docs)] + log_bytes32(log_bytes32), + #[allow(missing_docs)] + log_int(log_int), + #[allow(missing_docs)] + log_named_address(log_named_address), + #[allow(missing_docs)] + log_named_array_0(log_named_array_0), + #[allow(missing_docs)] + log_named_array_1(log_named_array_1), + #[allow(missing_docs)] + log_named_array_2(log_named_array_2), + #[allow(missing_docs)] + log_named_bytes(log_named_bytes), + #[allow(missing_docs)] + log_named_bytes32(log_named_bytes32), + #[allow(missing_docs)] + log_named_decimal_int(log_named_decimal_int), + #[allow(missing_docs)] + log_named_decimal_uint(log_named_decimal_uint), + #[allow(missing_docs)] + log_named_int(log_named_int), + #[allow(missing_docs)] + log_named_string(log_named_string), + #[allow(missing_docs)] + log_named_uint(log_named_uint), + #[allow(missing_docs)] + log_string(log_string), + #[allow(missing_docs)] + log_uint(log_uint), + #[allow(missing_docs)] + logs(logs), + } + #[automatically_derived] + impl BedrockStrategyForkedEvents { + /// 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]] = &[ + [ + 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, + 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, + 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, + ], + [ + 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, + 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, + 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, + ], + [ + 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, + 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, + 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, + ], + [ + 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, + 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, + 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, + ], + [ + 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, + 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, + 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, + ], + [ + 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, + 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, + 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, + ], + [ + 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, + 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, + 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, + ], + [ + 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, + 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, + 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, + ], + [ + 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, + 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, + 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, + ], + [ + 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, + 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, + 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, + ], + [ + 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, + 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, + 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, + ], + [ + 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, + 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, + 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, + ], + [ + 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, + 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, + 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, + ], + [ + 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, + 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, + 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, + ], + [ + 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, + 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, + 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, + ], + [ + 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, + 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, + 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, + ], + [ + 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, + 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, + 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, + ], + [ + 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, + 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, + 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, + ], + [ + 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, + 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, + 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, + ], + [ + 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, + 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, + 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, + ], + [ + 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, + 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, + 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, + ], + [ + 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, + 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, + 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for BedrockStrategyForkedEvents { + const NAME: &'static str = "BedrockStrategyForkedEvents"; + const COUNT: usize = 22usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_address) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_0) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_1) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_2) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_bytes) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_bytes32) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log_int) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_address) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_0) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_1) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_2) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_bytes) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_bytes32) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_decimal_int) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_decimal_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_int) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_string) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_string) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::logs) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 BedrockStrategyForkedEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::log(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_address(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_0(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_1(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_2(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_bytes(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_address(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_0(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_1(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_2(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_bytes(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_decimal_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_decimal_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_string(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_string(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::logs(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::log(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_address(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_0(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_1(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_2(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_bytes(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_address(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_0(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_1(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_2(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_bytes(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_decimal_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_decimal_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_string(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_string(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::logs(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`BedrockStrategyForked`](self) contract instance. + +See the [wrapper's documentation](`BedrockStrategyForkedInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> BedrockStrategyForkedInstance { + BedrockStrategyForkedInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + BedrockStrategyForkedInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + BedrockStrategyForkedInstance::::deploy_builder(provider) + } + /**A [`BedrockStrategyForked`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`BedrockStrategyForked`](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 BedrockStrategyForkedInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for BedrockStrategyForkedInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("BedrockStrategyForkedInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BedrockStrategyForkedInstance { + /**Creates a new wrapper around an on-chain [`BedrockStrategyForked`](self) contract instance. + +See the [wrapper's documentation](`BedrockStrategyForkedInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 BedrockStrategyForkedInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> BedrockStrategyForkedInstance { + BedrockStrategyForkedInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BedrockStrategyForkedInstance { + /// 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( + &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 [`IS_TEST`] function. + pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { + self.call_builder(&IS_TESTCall) + } + ///Creates a new call builder for the [`excludeArtifacts`] function. + pub fn excludeArtifacts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { + self.call_builder(&excludeArtifactsCall) + } + ///Creates a new call builder for the [`excludeContracts`] function. + pub fn excludeContracts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { + self.call_builder(&excludeContractsCall) + } + ///Creates a new call builder for the [`excludeSelectors`] function. + pub fn excludeSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { + self.call_builder(&excludeSelectorsCall) + } + ///Creates a new call builder for the [`excludeSenders`] function. + pub fn excludeSenders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { + self.call_builder(&excludeSendersCall) + } + ///Creates a new call builder for the [`failed`] function. + pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { + self.call_builder(&failedCall) + } + ///Creates a new call builder for the [`setUp`] function. + pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { + self.call_builder(&setUpCall) + } + ///Creates a new call builder for the [`simulateForkAndTransfer`] function. + pub fn simulateForkAndTransfer( + &self, + forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + sender: alloy::sol_types::private::Address, + receiver: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { + self.call_builder( + &simulateForkAndTransferCall { + forkAtBlock, + sender, + receiver, + amount, + }, + ) + } + ///Creates a new call builder for the [`targetArtifactSelectors`] function. + pub fn targetArtifactSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { + self.call_builder(&targetArtifactSelectorsCall) + } + ///Creates a new call builder for the [`targetArtifacts`] function. + pub fn targetArtifacts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { + self.call_builder(&targetArtifactsCall) + } + ///Creates a new call builder for the [`targetContracts`] function. + pub fn targetContracts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { + self.call_builder(&targetContractsCall) + } + ///Creates a new call builder for the [`targetInterfaces`] function. + pub fn targetInterfaces( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { + self.call_builder(&targetInterfacesCall) + } + ///Creates a new call builder for the [`targetSelectors`] function. + pub fn targetSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { + self.call_builder(&targetSelectorsCall) + } + ///Creates a new call builder for the [`targetSenders`] function. + pub fn targetSenders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { + self.call_builder(&targetSendersCall) + } + ///Creates a new call builder for the [`testBedrockStrategy`] function. + pub fn testBedrockStrategy( + &self, + ) -> alloy_contract::SolCallBuilder<&P, testBedrockStrategyCall, N> { + self.call_builder(&testBedrockStrategyCall) + } + ///Creates a new call builder for the [`token`] function. + pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { + self.call_builder(&tokenCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BedrockStrategyForkedInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`log`] event. + pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_address`] event. + pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_0`] event. + pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_1`] event. + pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_2`] event. + pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_bytes`] event. + pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_bytes32`] event. + pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_int`] event. + pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_address`] event. + pub fn log_named_address_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_address, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_0`] event. + pub fn log_named_array_0_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_0, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_1`] event. + pub fn log_named_array_1_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_1, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_2`] event. + pub fn log_named_array_2_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_2, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_bytes`] event. + pub fn log_named_bytes_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_bytes, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_bytes32`] event. + pub fn log_named_bytes32_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_bytes32, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_decimal_int`] event. + pub fn log_named_decimal_int_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_decimal_uint`] event. + pub fn log_named_decimal_uint_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_int`] event. + pub fn log_named_int_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_string`] event. + pub fn log_named_string_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_string, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_uint`] event. + pub fn log_named_uint_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_string`] event. + pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_uint`] event. + pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`logs`] event. + pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/bitcoin_tx.rs b/crates/bindings/src/bitcoin_tx.rs new file mode 100644 index 000000000..fac25a1ca --- /dev/null +++ b/crates/bindings/src/bitcoin_tx.rs @@ -0,0 +1,218 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface BitcoinTx {} +``` + +...which was generated by the following JSON ABI: +```json +[] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod BitcoinTx { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220a68ee4a95430b1a47f2aaf420ef14a7f295c85c26a631128e0b894b630ddc31364736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`U`2`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`&WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \xA6\x8E\xE4\xA9T0\xB1\xA4\x7F*\xAFB\x0E\xF1J\x7F)\\\x85\xC2jc\x11(\xE0\xB8\x94\xB60\xDD\xC3\x13dsolcC\0\x08\x1C\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220a68ee4a95430b1a47f2aaf420ef14a7f295c85c26a631128e0b894b630ddc31364736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \xA6\x8E\xE4\xA9T0\xB1\xA4\x7F*\xAFB\x0E\xF1J\x7F)\\\x85\xC2jc\x11(\xE0\xB8\x94\xB60\xDD\xC3\x13dsolcC\0\x08\x1C\x003", + ); + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`BitcoinTx`](self) contract instance. + +See the [wrapper's documentation](`BitcoinTxInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> BitcoinTxInstance { + BitcoinTxInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + BitcoinTxInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + BitcoinTxInstance::::deploy_builder(provider) + } + /**A [`BitcoinTx`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`BitcoinTx`](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 BitcoinTxInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for BitcoinTxInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("BitcoinTxInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BitcoinTxInstance { + /**Creates a new wrapper around an on-chain [`BitcoinTx`](self) contract instance. + +See the [wrapper's documentation](`BitcoinTxInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 BitcoinTxInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> BitcoinTxInstance { + BitcoinTxInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BitcoinTxInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BitcoinTxInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/bitcoin_tx_builder.rs b/crates/bindings/src/bitcoin_tx_builder.rs new file mode 100644 index 000000000..790f71bb8 --- /dev/null +++ b/crates/bindings/src/bitcoin_tx_builder.rs @@ -0,0 +1,1571 @@ +///Module containing a contract's types and functions. +/** + +```solidity +library BitcoinTx { + struct Info { bytes4 version; bytes inputVector; bytes outputVector; bytes4 locktime; } +} +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod BitcoinTx { + use super::*; + use alloy::sol_types as alloy_sol_types; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct Info { bytes4 version; bytes inputVector; bytes outputVector; bytes4 locktime; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Info { + #[allow(missing_docs)] + pub version: alloy::sol_types::private::FixedBytes<4>, + #[allow(missing_docs)] + pub inputVector: alloy::sol_types::private::Bytes, + #[allow(missing_docs)] + pub outputVector: alloy::sol_types::private::Bytes, + #[allow(missing_docs)] + pub locktime: 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 as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::FixedBytes<4>, + alloy::sol_types::sol_data::Bytes, + alloy::sol_types::sol_data::Bytes, + alloy::sol_types::sol_data::FixedBytes<4>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::FixedBytes<4>, + alloy::sol_types::private::Bytes, + alloy::sol_types::private::Bytes, + alloy::sol_types::private::FixedBytes<4>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: Info) -> Self { + (value.version, value.inputVector, value.outputVector, value.locktime) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for Info { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + version: tuple.0, + inputVector: tuple.1, + outputVector: tuple.2, + locktime: tuple.3, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for Info { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for Info { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.version), + ::tokenize( + &self.inputVector, + ), + ::tokenize( + &self.outputVector, + ), + as alloy_sol_types::SolType>::tokenize(&self.locktime), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Info { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for Info { + const NAME: &'static str = "Info"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "Info(bytes4 version,bytes inputVector,bytes outputVector,bytes4 locktime)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + as alloy_sol_types::SolType>::eip712_data_word(&self.version) + .0, + ::eip712_data_word( + &self.inputVector, + ) + .0, + ::eip712_data_word( + &self.outputVector, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.locktime) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Info { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.version, + ) + + ::topic_preimage_length( + &rust.inputVector, + ) + + ::topic_preimage_length( + &rust.outputVector, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.locktime, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.version, + out, + ); + ::encode_topic_preimage( + &rust.inputVector, + out, + ); + ::encode_topic_preimage( + &rust.outputVector, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.locktime, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`BitcoinTx`](self) contract instance. + +See the [wrapper's documentation](`BitcoinTxInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> BitcoinTxInstance { + BitcoinTxInstance::::new(address, provider) + } + /**A [`BitcoinTx`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`BitcoinTx`](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 BitcoinTxInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for BitcoinTxInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("BitcoinTxInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BitcoinTxInstance { + /**Creates a new wrapper around an on-chain [`BitcoinTx`](self) contract instance. + +See the [wrapper's documentation](`BitcoinTxInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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 BitcoinTxInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> BitcoinTxInstance { + BitcoinTxInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BitcoinTxInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BitcoinTxInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} +/** + +Generated by the following Solidity interface... +```solidity +library BitcoinTx { + struct Info { + bytes4 version; + bytes inputVector; + bytes outputVector; + bytes4 locktime; + } +} + +interface BitcoinTxBuilder { + function build() external view returns (BitcoinTx.Info memory); + function setOpReturn(bytes memory _data) external returns (address); + function setScript(bytes memory _script) external returns (address); + function setValue(uint64 _value) external returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "build", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "tuple", + "internalType": "struct BitcoinTx.Info", + "components": [ + { + "name": "version", + "type": "bytes4", + "internalType": "bytes4" + }, + { + "name": "inputVector", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "outputVector", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "locktime", + "type": "bytes4", + "internalType": "bytes4" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "setOpReturn", + "inputs": [ + { + "name": "_data", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract BitcoinTxBuilder" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setScript", + "inputs": [ + { + "name": "_script", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract BitcoinTxBuilder" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setValue", + "inputs": [ + { + "name": "_value", + "type": "uint64", + "internalType": "uint64" + } + ], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract BitcoinTxBuilder" + } + ], + "stateMutability": "nonpayable" + } +] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod BitcoinTxBuilder { + use super::*; + use alloy::sol_types as 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\ts\x80a\0\x1C_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\r\x15\xA3J\x14a\0NW\x80c\x1CN\xD3'\x14a\0\x8BW\x80c\x8E\x1AU\xFC\x14a\0\xD6W\x80c\xFC\xAB^H\x14a\0\xEBW[__\xFD[a\0aa\0\\6`\x04a\x04LV[a\0\xFEV[`@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\0aa\0\x996`\x04a\x05\0V[`\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\0\0\0\0\0\0\0\0\x16g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x90\x92\x16\x91\x90\x91\x17\x90U0\x90V[a\0\xDEa\x01\x12V[`@Qa\0\x82\x91\x90a\x05\\V[a\0aa\0\xF96`\x04a\x04LV[a\x03\xDFV[_\x80a\x01\n\x83\x82a\x06\x96V[P0\x92\x91PPV[`@\x80Q`\x80\x81\x01\x82R_\x80\x82R``` \x83\x01\x81\x90R\x92\x82\x01\x83\x90R\x91\x81\x01\x91\x90\x91R_\x80T\x81\x90a\x01D\x90a\x05\xF9V[\x90P\x11a\x01\xB2W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x7FScript cannot be empty\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`\x01Th\x01\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x02DW`P_`\x02\x01\x80Ta\x01\xDA\x90a\x05\xF9V[\x90P\x11\x15a\x02DW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x7FOP_RETURN data too large\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x01\xA9V[`\x01T_\x90e\xFF\xFF\0\0\xFF\xFFg\xFF\0\xFF\0\xFF\0\xFF\0`\x08\x83\x81\x1B\x91\x82\x16f\xFF\0\xFF\0\xFF\0\xFF\x94\x90\x91\x1C\x93\x84\x16\x17`\x10\x90\x81\x1C\x92\x90\x92\x16e\xFF\0\0\0\xFF\0\x91\x90\x91\x16d\xFF\0\0\0\xFF\x93\x90\x93\x16\x92\x90\x92\x17\x90\x1Bg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17` \x81\x81\x1B\x91\x90\x1C\x17`\xC0\x1B`@Q` \x01a\x02\xE4\x91\x90\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\x91\x90\x91\x16\x81R`\x08\x01\x90V[`@\x80Q\x80\x83\x03`\x1F\x19\x01\x81R\x91\x90R`\x01\x80T\x91\x92P\x90h\x01\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x03\x1EWa\x03\x1B`\x01\x82a\x07~V[\x90P[`@Q_\x90a\x035\x90\x83\x90\x85\x90\x84\x90` \x01a\x08@V[`@\x80Q\x80\x83\x03`\x1F\x19\x01\x81R\x91\x90R`\x01T\x90\x91Ph\x01\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x03\xAFW\x80_`\x02\x01\x80Ta\x03o\x90a\x05\xF9V[a\x03{\x91P`\x02a\x08\x88V[`\x02\x80Ta\x03\x88\x90a\x05\xF9V[`@Qa\x03\x9D\x94\x93\x92P`\x02\x90` \x01a\x08\x9BV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90P[`@\x80Q`\x80\x81\x01\x82R_\x80\x82R\x82Q` \x81\x81\x01\x85R\x82\x82R\x83\x01R\x91\x81\x01\x92\x90\x92R``\x82\x01R\x93\x92PPPV[`\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\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16h\x01\0\0\0\0\0\0\0\0\x17\x90U_`\x02a\x01\n\x83\x82a\x06\x96V[\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\x04\\W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x04rW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x04\x82W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x04\x9CWa\x04\x9Ca\x04\x1FV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x04\xCCWa\x04\xCCa\x04\x1FV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x04\xE3W__\xFD[\x81` \x84\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[_` \x82\x84\x03\x12\x15a\x05\x10W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x05'W__\xFD[\x93\x92PPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R\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\x82Q\x16` \x82\x01R_` \x83\x01Q`\x80`@\x84\x01Ra\x05\xA3`\xA0\x84\x01\x82a\x05.V[\x90P`@\x84\x01Q`\x1F\x19\x84\x83\x03\x01``\x85\x01Ra\x05\xC0\x82\x82a\x05.V[\x91PP\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``\x85\x01Q\x16`\x80\x84\x01R\x80\x91PP\x92\x91PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x06\rW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x06DW\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[P\x91\x90PV[`\x1F\x82\x11\x15a\x06\x91W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x06oWP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x06\x8EW_\x81U`\x01\x01a\x06{V[PP[PPPV[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\xB0Wa\x06\xB0a\x04\x1FV[a\x06\xC4\x81a\x06\xBE\x84Ta\x05\xF9V[\x84a\x06JV[` `\x1F\x82\x11`\x01\x81\x14a\x06\xF6W_\x83\x15a\x06\xDFWP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x06\x8EV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x07%W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x07\x05V[P\x84\x82\x10\x15a\x07BW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[\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[`\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x07\x97Wa\x07\x97a\x07QV[\x92\x91PPV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_\x81Ta\x07\xC0\x81a\x05\xF9V[`\x01\x82\x16\x80\x15a\x07\xD7W`\x01\x81\x14a\x08\nWa\x087V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x83\x16\x86R\x81\x15\x15\x82\x02\x86\x01\x93Pa\x087V[\x84_R` _ _[\x83\x81\x10\x15a\x08/W\x81T\x88\x82\x01R`\x01\x90\x91\x01\x90` \x01a\x08\x13V[PP\x81\x86\x01\x93P[PPP\x92\x91PPV[\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\x84`\xF8\x1B\x16\x81R_a\x08\x7Fa\x08y`\x01\x84\x01\x86a\x07\x9DV[\x84a\x07\xB4V[\x95\x94PPPPPV[\x80\x82\x01\x80\x82\x11\x15a\x07\x97Wa\x07\x97a\x07QV[_a\x08\xA6\x82\x87a\x07\x9DV[_\x81R\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\x86`\xF8\x1B\x16`\x08\x82\x01R\x7Fj\0\0\0\0\0\0\0\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\x82\x01R\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\x85`\xF8\x1B\x16`\n\x82\x01Ra\t2`\x0B\x82\x01\x85a\x07\xB4V[\x97\x96PPPPPPPV\xFE\xA2dipfsX\"\x12 p\xD9\xC0\xD4\n7\xF7E_\x06\x13\xEB\x14\xD5\xEF\xEEa>\xA6\xFE,\xD3P\xE4\xA4\xB0Sd]\x92\xA6XdsolcC\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\r\x15\xA3J\x14a\0NW\x80c\x1CN\xD3'\x14a\0\x8BW\x80c\x8E\x1AU\xFC\x14a\0\xD6W\x80c\xFC\xAB^H\x14a\0\xEBW[__\xFD[a\0aa\0\\6`\x04a\x04LV[a\0\xFEV[`@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\0aa\0\x996`\x04a\x05\0V[`\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\0\0\0\0\0\0\0\0\x16g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x90\x92\x16\x91\x90\x91\x17\x90U0\x90V[a\0\xDEa\x01\x12V[`@Qa\0\x82\x91\x90a\x05\\V[a\0aa\0\xF96`\x04a\x04LV[a\x03\xDFV[_\x80a\x01\n\x83\x82a\x06\x96V[P0\x92\x91PPV[`@\x80Q`\x80\x81\x01\x82R_\x80\x82R``` \x83\x01\x81\x90R\x92\x82\x01\x83\x90R\x91\x81\x01\x91\x90\x91R_\x80T\x81\x90a\x01D\x90a\x05\xF9V[\x90P\x11a\x01\xB2W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x7FScript cannot be empty\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`\x01Th\x01\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x02DW`P_`\x02\x01\x80Ta\x01\xDA\x90a\x05\xF9V[\x90P\x11\x15a\x02DW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x7FOP_RETURN data too large\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x01\xA9V[`\x01T_\x90e\xFF\xFF\0\0\xFF\xFFg\xFF\0\xFF\0\xFF\0\xFF\0`\x08\x83\x81\x1B\x91\x82\x16f\xFF\0\xFF\0\xFF\0\xFF\x94\x90\x91\x1C\x93\x84\x16\x17`\x10\x90\x81\x1C\x92\x90\x92\x16e\xFF\0\0\0\xFF\0\x91\x90\x91\x16d\xFF\0\0\0\xFF\x93\x90\x93\x16\x92\x90\x92\x17\x90\x1Bg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17` \x81\x81\x1B\x91\x90\x1C\x17`\xC0\x1B`@Q` \x01a\x02\xE4\x91\x90\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\x91\x90\x91\x16\x81R`\x08\x01\x90V[`@\x80Q\x80\x83\x03`\x1F\x19\x01\x81R\x91\x90R`\x01\x80T\x91\x92P\x90h\x01\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x03\x1EWa\x03\x1B`\x01\x82a\x07~V[\x90P[`@Q_\x90a\x035\x90\x83\x90\x85\x90\x84\x90` \x01a\x08@V[`@\x80Q\x80\x83\x03`\x1F\x19\x01\x81R\x91\x90R`\x01T\x90\x91Ph\x01\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x03\xAFW\x80_`\x02\x01\x80Ta\x03o\x90a\x05\xF9V[a\x03{\x91P`\x02a\x08\x88V[`\x02\x80Ta\x03\x88\x90a\x05\xF9V[`@Qa\x03\x9D\x94\x93\x92P`\x02\x90` \x01a\x08\x9BV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90P[`@\x80Q`\x80\x81\x01\x82R_\x80\x82R\x82Q` \x81\x81\x01\x85R\x82\x82R\x83\x01R\x91\x81\x01\x92\x90\x92R``\x82\x01R\x93\x92PPPV[`\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\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16h\x01\0\0\0\0\0\0\0\0\x17\x90U_`\x02a\x01\n\x83\x82a\x06\x96V[\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\x04\\W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x04rW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x04\x82W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x04\x9CWa\x04\x9Ca\x04\x1FV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x04\xCCWa\x04\xCCa\x04\x1FV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x04\xE3W__\xFD[\x81` \x84\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[_` \x82\x84\x03\x12\x15a\x05\x10W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x05'W__\xFD[\x93\x92PPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R\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\x82Q\x16` \x82\x01R_` \x83\x01Q`\x80`@\x84\x01Ra\x05\xA3`\xA0\x84\x01\x82a\x05.V[\x90P`@\x84\x01Q`\x1F\x19\x84\x83\x03\x01``\x85\x01Ra\x05\xC0\x82\x82a\x05.V[\x91PP\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``\x85\x01Q\x16`\x80\x84\x01R\x80\x91PP\x92\x91PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x06\rW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x06DW\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[P\x91\x90PV[`\x1F\x82\x11\x15a\x06\x91W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x06oWP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x06\x8EW_\x81U`\x01\x01a\x06{V[PP[PPPV[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\xB0Wa\x06\xB0a\x04\x1FV[a\x06\xC4\x81a\x06\xBE\x84Ta\x05\xF9V[\x84a\x06JV[` `\x1F\x82\x11`\x01\x81\x14a\x06\xF6W_\x83\x15a\x06\xDFWP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x06\x8EV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x07%W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x07\x05V[P\x84\x82\x10\x15a\x07BW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[\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[`\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x07\x97Wa\x07\x97a\x07QV[\x92\x91PPV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_\x81Ta\x07\xC0\x81a\x05\xF9V[`\x01\x82\x16\x80\x15a\x07\xD7W`\x01\x81\x14a\x08\nWa\x087V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x83\x16\x86R\x81\x15\x15\x82\x02\x86\x01\x93Pa\x087V[\x84_R` _ _[\x83\x81\x10\x15a\x08/W\x81T\x88\x82\x01R`\x01\x90\x91\x01\x90` \x01a\x08\x13V[PP\x81\x86\x01\x93P[PPP\x92\x91PPV[\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\x84`\xF8\x1B\x16\x81R_a\x08\x7Fa\x08y`\x01\x84\x01\x86a\x07\x9DV[\x84a\x07\xB4V[\x95\x94PPPPPV[\x80\x82\x01\x80\x82\x11\x15a\x07\x97Wa\x07\x97a\x07QV[_a\x08\xA6\x82\x87a\x07\x9DV[_\x81R\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\x86`\xF8\x1B\x16`\x08\x82\x01R\x7Fj\0\0\0\0\0\0\0\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\x82\x01R\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\x85`\xF8\x1B\x16`\n\x82\x01Ra\t2`\x0B\x82\x01\x85a\x07\xB4V[\x97\x96PPPPPPPV\xFE\xA2dipfsX\"\x12 p\xD9\xC0\xD4\n7\xF7E_\x06\x13\xEB\x14\xD5\xEF\xEEa>\xA6\xFE,\xD3P\xE4\xA4\xB0Sd]\x92\xA6XdsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `build()` and selector `0x8e1a55fc`. +```solidity +function build() external view returns (BitcoinTx.Info memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct buildCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`build()`](buildCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct buildReturn { + #[allow(missing_docs)] + pub _0: ::RustType, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: buildCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for buildCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (BitcoinTx::Info,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: buildReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for buildReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for buildCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ::RustType; + type ReturnTuple<'a> = (BitcoinTx::Info,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "build()"; + const SELECTOR: [u8; 4] = [142u8, 26u8, 85u8, 252u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + (::tokenize(ret),) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: buildReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: buildReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `setOpReturn(bytes)` and selector `0xfcab5e48`. +```solidity +function setOpReturn(bytes memory _data) external returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setOpReturnCall { + #[allow(missing_docs)] + pub _data: alloy::sol_types::private::Bytes, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`setOpReturn(bytes)`](setOpReturnCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setOpReturnReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setOpReturnCall) -> Self { + (value._data,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setOpReturnCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _data: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setOpReturnReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setOpReturnReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setOpReturnCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Bytes,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setOpReturn(bytes)"; + const SELECTOR: [u8; 4] = [252u8, 171u8, 94u8, 72u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._data, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: setOpReturnReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: setOpReturnReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `setScript(bytes)` and selector `0x0d15a34a`. +```solidity +function setScript(bytes memory _script) external returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setScriptCall { + #[allow(missing_docs)] + pub _script: alloy::sol_types::private::Bytes, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`setScript(bytes)`](setScriptCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setScriptReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setScriptCall) -> Self { + (value._script,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setScriptCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _script: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setScriptReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setScriptReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setScriptCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Bytes,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setScript(bytes)"; + const SELECTOR: [u8; 4] = [13u8, 21u8, 163u8, 74u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._script, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: setScriptReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: setScriptReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `setValue(uint64)` and selector `0x1c4ed327`. +```solidity +function setValue(uint64 _value) external returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setValueCall { + #[allow(missing_docs)] + pub _value: u64, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`setValue(uint64)`](setValueCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setValueReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (u64,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setValueCall) -> Self { + (value._value,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setValueCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _value: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setValueReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setValueReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setValueCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<64>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setValue(uint64)"; + const SELECTOR: [u8; 4] = [28u8, 78u8, 211u8, 39u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._value), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: setValueReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: setValueReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`BitcoinTxBuilder`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum BitcoinTxBuilderCalls { + #[allow(missing_docs)] + build(buildCall), + #[allow(missing_docs)] + setOpReturn(setOpReturnCall), + #[allow(missing_docs)] + setScript(setScriptCall), + #[allow(missing_docs)] + setValue(setValueCall), + } + #[automatically_derived] + impl BitcoinTxBuilderCalls { + /// 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, 21u8, 163u8, 74u8], + [28u8, 78u8, 211u8, 39u8], + [142u8, 26u8, 85u8, 252u8], + [252u8, 171u8, 94u8, 72u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for BitcoinTxBuilderCalls { + const NAME: &'static str = "BitcoinTxBuilderCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 4usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::build(_) => ::SELECTOR, + Self::setOpReturn(_) => { + ::SELECTOR + } + Self::setScript(_) => { + ::SELECTOR + } + Self::setValue(_) => ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn setScript( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(BitcoinTxBuilderCalls::setScript) + } + setScript + }, + { + fn setValue( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(BitcoinTxBuilderCalls::setValue) + } + setValue + }, + { + fn build( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(BitcoinTxBuilderCalls::build) + } + build + }, + { + fn setOpReturn( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BitcoinTxBuilderCalls::setOpReturn) + } + setOpReturn + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn setScript( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BitcoinTxBuilderCalls::setScript) + } + setScript + }, + { + fn setValue( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BitcoinTxBuilderCalls::setValue) + } + setValue + }, + { + fn build( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BitcoinTxBuilderCalls::build) + } + build + }, + { + fn setOpReturn( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BitcoinTxBuilderCalls::setOpReturn) + } + setOpReturn + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::build(inner) => { + ::abi_encoded_size(inner) + } + Self::setOpReturn(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::setScript(inner) => { + ::abi_encoded_size(inner) + } + Self::setValue(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::build(inner) => { + ::abi_encode_raw(inner, out) + } + Self::setOpReturn(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::setScript(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::setValue(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`BitcoinTxBuilder`](self) contract instance. + +See the [wrapper's documentation](`BitcoinTxBuilderInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> BitcoinTxBuilderInstance { + BitcoinTxBuilderInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + BitcoinTxBuilderInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + BitcoinTxBuilderInstance::::deploy_builder(provider) + } + /**A [`BitcoinTxBuilder`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`BitcoinTxBuilder`](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 BitcoinTxBuilderInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for BitcoinTxBuilderInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("BitcoinTxBuilderInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BitcoinTxBuilderInstance { + /**Creates a new wrapper around an on-chain [`BitcoinTxBuilder`](self) contract instance. + +See the [wrapper's documentation](`BitcoinTxBuilderInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 BitcoinTxBuilderInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> BitcoinTxBuilderInstance { + BitcoinTxBuilderInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BitcoinTxBuilderInstance { + /// 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( + &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 [`build`] function. + pub fn build(&self) -> alloy_contract::SolCallBuilder<&P, buildCall, N> { + self.call_builder(&buildCall) + } + ///Creates a new call builder for the [`setOpReturn`] function. + pub fn setOpReturn( + &self, + _data: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, setOpReturnCall, N> { + self.call_builder(&setOpReturnCall { _data }) + } + ///Creates a new call builder for the [`setScript`] function. + pub fn setScript( + &self, + _script: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, setScriptCall, N> { + self.call_builder(&setScriptCall { _script }) + } + ///Creates a new call builder for the [`setValue`] function. + pub fn setValue( + &self, + _value: u64, + ) -> alloy_contract::SolCallBuilder<&P, setValueCall, N> { + self.call_builder(&setValueCall { _value }) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BitcoinTxBuilderInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/btc_market_place.rs b/crates/bindings/src/btc_market_place.rs new file mode 100644 index 000000000..c556a2877 --- /dev/null +++ b/crates/bindings/src/btc_market_place.rs @@ -0,0 +1,9865 @@ +///Module containing a contract's types and functions. +/** + +```solidity +library BitcoinTx { + struct Info { bytes4 version; bytes inputVector; bytes outputVector; bytes4 locktime; } + struct Proof { bytes merkleProof; uint256 txIndexInBlock; bytes bitcoinHeaders; bytes32 coinbasePreimage; bytes coinbaseProof; } +} +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod BitcoinTx { + use super::*; + use alloy::sol_types as alloy_sol_types; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct Info { bytes4 version; bytes inputVector; bytes outputVector; bytes4 locktime; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Info { + #[allow(missing_docs)] + pub version: alloy::sol_types::private::FixedBytes<4>, + #[allow(missing_docs)] + pub inputVector: alloy::sol_types::private::Bytes, + #[allow(missing_docs)] + pub outputVector: alloy::sol_types::private::Bytes, + #[allow(missing_docs)] + pub locktime: 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 as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::FixedBytes<4>, + alloy::sol_types::sol_data::Bytes, + alloy::sol_types::sol_data::Bytes, + alloy::sol_types::sol_data::FixedBytes<4>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::FixedBytes<4>, + alloy::sol_types::private::Bytes, + alloy::sol_types::private::Bytes, + alloy::sol_types::private::FixedBytes<4>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: Info) -> Self { + (value.version, value.inputVector, value.outputVector, value.locktime) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for Info { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + version: tuple.0, + inputVector: tuple.1, + outputVector: tuple.2, + locktime: tuple.3, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for Info { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for Info { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.version), + ::tokenize( + &self.inputVector, + ), + ::tokenize( + &self.outputVector, + ), + as alloy_sol_types::SolType>::tokenize(&self.locktime), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Info { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for Info { + const NAME: &'static str = "Info"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "Info(bytes4 version,bytes inputVector,bytes outputVector,bytes4 locktime)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + as alloy_sol_types::SolType>::eip712_data_word(&self.version) + .0, + ::eip712_data_word( + &self.inputVector, + ) + .0, + ::eip712_data_word( + &self.outputVector, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.locktime) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Info { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.version, + ) + + ::topic_preimage_length( + &rust.inputVector, + ) + + ::topic_preimage_length( + &rust.outputVector, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.locktime, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.version, + out, + ); + ::encode_topic_preimage( + &rust.inputVector, + out, + ); + ::encode_topic_preimage( + &rust.outputVector, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.locktime, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct Proof { bytes merkleProof; uint256 txIndexInBlock; bytes bitcoinHeaders; bytes32 coinbasePreimage; bytes coinbaseProof; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Proof { + #[allow(missing_docs)] + pub merkleProof: alloy::sol_types::private::Bytes, + #[allow(missing_docs)] + pub txIndexInBlock: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub bitcoinHeaders: alloy::sol_types::private::Bytes, + #[allow(missing_docs)] + pub coinbasePreimage: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub coinbaseProof: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Bytes, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Bytes, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Bytes, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Bytes, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Bytes, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: Proof) -> Self { + ( + value.merkleProof, + value.txIndexInBlock, + value.bitcoinHeaders, + value.coinbasePreimage, + value.coinbaseProof, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for Proof { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + merkleProof: tuple.0, + txIndexInBlock: tuple.1, + bitcoinHeaders: tuple.2, + coinbasePreimage: tuple.3, + coinbaseProof: tuple.4, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for Proof { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for Proof { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.merkleProof, + ), + as alloy_sol_types::SolType>::tokenize(&self.txIndexInBlock), + ::tokenize( + &self.bitcoinHeaders, + ), + as alloy_sol_types::SolType>::tokenize(&self.coinbasePreimage), + ::tokenize( + &self.coinbaseProof, + ), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Proof { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for Proof { + const NAME: &'static str = "Proof"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "Proof(bytes merkleProof,uint256 txIndexInBlock,bytes bitcoinHeaders,bytes32 coinbasePreimage,bytes coinbaseProof)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.merkleProof, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word( + &self.txIndexInBlock, + ) + .0, + ::eip712_data_word( + &self.bitcoinHeaders, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word( + &self.coinbasePreimage, + ) + .0, + ::eip712_data_word( + &self.coinbaseProof, + ) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Proof { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.merkleProof, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.txIndexInBlock, + ) + + ::topic_preimage_length( + &rust.bitcoinHeaders, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.coinbasePreimage, + ) + + ::topic_preimage_length( + &rust.coinbaseProof, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.merkleProof, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.txIndexInBlock, + out, + ); + ::encode_topic_preimage( + &rust.bitcoinHeaders, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.coinbasePreimage, + out, + ); + ::encode_topic_preimage( + &rust.coinbaseProof, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`BitcoinTx`](self) contract instance. + +See the [wrapper's documentation](`BitcoinTxInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> BitcoinTxInstance { + BitcoinTxInstance::::new(address, provider) + } + /**A [`BitcoinTx`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`BitcoinTx`](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 BitcoinTxInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for BitcoinTxInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("BitcoinTxInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BitcoinTxInstance { + /**Creates a new wrapper around an on-chain [`BitcoinTx`](self) contract instance. + +See the [wrapper's documentation](`BitcoinTxInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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 BitcoinTxInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> BitcoinTxInstance { + BitcoinTxInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BitcoinTxInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BitcoinTxInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} +/** + +Generated by the following Solidity interface... +```solidity +library BitcoinTx { + struct Info { + bytes4 version; + bytes inputVector; + bytes outputVector; + bytes4 locktime; + } + struct Proof { + bytes merkleProof; + uint256 txIndexInBlock; + bytes bitcoinHeaders; + bytes32 coinbasePreimage; + bytes coinbaseProof; + } +} + +interface BtcMarketPlace { + struct AcceptedBtcBuyOrder { + uint256 orderId; + uint256 amountBtc; + address ercToken; + uint256 ercAmount; + address requester; + address accepter; + uint256 acceptTime; + } + struct AcceptedBtcSellOrder { + uint256 orderId; + BitcoinAddress bitcoinAddress; + uint256 amountBtc; + address ercToken; + uint256 ercAmount; + address requester; + address accepter; + uint256 acceptTime; + } + struct BitcoinAddress { + bytes scriptPubKey; + } + struct BtcBuyOrder { + uint256 amountBtc; + BitcoinAddress bitcoinAddress; + address offeringToken; + uint256 offeringAmount; + address requester; + } + struct BtcSellOrder { + uint256 amountBtc; + address askingToken; + uint256 askingAmount; + address requester; + } + + event acceptBtcBuyOrderEvent(uint256 indexed orderId, uint256 indexed acceptId, uint256 amountBtc, uint256 ercAmount, address ercToken); + event acceptBtcSellOrderEvent(uint256 indexed id, uint256 indexed acceptId, BitcoinAddress bitcoinAddress, uint256 amountBtc, uint256 ercAmount, address ercToken); + event cancelAcceptedBtcBuyOrderEvent(uint256 id); + event cancelAcceptedBtcSellOrderEvent(uint256 id); + event placeBtcBuyOrderEvent(uint256 amountBtc, BitcoinAddress bitcoinAddress, address sellingToken, uint256 saleAmount); + event placeBtcSellOrderEvent(uint256 indexed orderId, uint256 amountBtc, address buyingToken, uint256 buyAmount); + event proofBtcBuyOrderEvent(uint256 id); + event proofBtcSellOrderEvent(uint256 id); + event withdrawBtcBuyOrderEvent(uint256 id); + event withdrawBtcSellOrderEvent(uint256 id); + + constructor(address _relay, address erc2771Forwarder); + + function REQUEST_EXPIRATION_SECONDS() external view returns (uint256); + function acceptBtcBuyOrder(uint256 id, uint256 amountBtc) external returns (uint256); + function acceptBtcSellOrder(uint256 id, BitcoinAddress memory bitcoinAddress, uint256 amountBtc) external returns (uint256); + function acceptedBtcBuyOrders(uint256) external view returns (uint256 orderId, uint256 amountBtc, address ercToken, uint256 ercAmount, address requester, address accepter, uint256 acceptTime); + function acceptedBtcSellOrders(uint256) external view returns (uint256 orderId, BitcoinAddress memory bitcoinAddress, uint256 amountBtc, address ercToken, uint256 ercAmount, address requester, address accepter, uint256 acceptTime); + function btcBuyOrders(uint256) external view returns (uint256 amountBtc, BitcoinAddress memory bitcoinAddress, address offeringToken, uint256 offeringAmount, address requester); + function btcSellOrders(uint256) external view returns (uint256 amountBtc, address askingToken, uint256 askingAmount, address requester); + function cancelAcceptedBtcBuyOrder(uint256 id) external; + function cancelAcceptedBtcSellOrder(uint256 id) external; + function getOpenAcceptedBtcBuyOrders() external view returns (AcceptedBtcBuyOrder[] memory, uint256[] memory); + function getOpenAcceptedBtcSellOrders() external view returns (AcceptedBtcSellOrder[] memory, uint256[] memory); + function getOpenBtcBuyOrders() external view returns (BtcBuyOrder[] memory, uint256[] memory); + function getOpenBtcSellOrders() external view returns (BtcSellOrder[] memory, uint256[] memory); + function getTrustedForwarder() external view returns (address forwarder); + function isTrustedForwarder(address forwarder) external view returns (bool); + function placeBtcBuyOrder(uint256 amountBtc, BitcoinAddress memory bitcoinAddress, address sellingToken, uint256 saleAmount) external; + function placeBtcSellOrder(uint256 amountBtc, address buyingToken, uint256 buyAmount) external; + function proofBtcBuyOrder(uint256 id, BitcoinTx.Info memory transaction, BitcoinTx.Proof memory proof) external; + function proofBtcSellOrder(uint256 id, BitcoinTx.Info memory transaction, BitcoinTx.Proof memory proof) external; + function withdrawBtcBuyOrder(uint256 id) external; + function withdrawBtcSellOrder(uint256 id) external; +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_relay", + "type": "address", + "internalType": "contract TestLightRelay" + }, + { + "name": "erc2771Forwarder", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "REQUEST_EXPIRATION_SECONDS", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "acceptBtcBuyOrder", + "inputs": [ + { + "name": "id", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "amountBtc", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "acceptBtcSellOrder", + "inputs": [ + { + "name": "id", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "bitcoinAddress", + "type": "tuple", + "internalType": "struct BtcMarketPlace.BitcoinAddress", + "components": [ + { + "name": "scriptPubKey", + "type": "bytes", + "internalType": "bytes" + } + ] + }, + { + "name": "amountBtc", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "acceptedBtcBuyOrders", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "orderId", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "amountBtc", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "ercToken", + "type": "address", + "internalType": "address" + }, + { + "name": "ercAmount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "requester", + "type": "address", + "internalType": "address" + }, + { + "name": "accepter", + "type": "address", + "internalType": "address" + }, + { + "name": "acceptTime", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "acceptedBtcSellOrders", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "orderId", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "bitcoinAddress", + "type": "tuple", + "internalType": "struct BtcMarketPlace.BitcoinAddress", + "components": [ + { + "name": "scriptPubKey", + "type": "bytes", + "internalType": "bytes" + } + ] + }, + { + "name": "amountBtc", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "ercToken", + "type": "address", + "internalType": "address" + }, + { + "name": "ercAmount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "requester", + "type": "address", + "internalType": "address" + }, + { + "name": "accepter", + "type": "address", + "internalType": "address" + }, + { + "name": "acceptTime", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "btcBuyOrders", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "amountBtc", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "bitcoinAddress", + "type": "tuple", + "internalType": "struct BtcMarketPlace.BitcoinAddress", + "components": [ + { + "name": "scriptPubKey", + "type": "bytes", + "internalType": "bytes" + } + ] + }, + { + "name": "offeringToken", + "type": "address", + "internalType": "address" + }, + { + "name": "offeringAmount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "requester", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "btcSellOrders", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "amountBtc", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "askingToken", + "type": "address", + "internalType": "address" + }, + { + "name": "askingAmount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "requester", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "cancelAcceptedBtcBuyOrder", + "inputs": [ + { + "name": "id", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "cancelAcceptedBtcSellOrder", + "inputs": [ + { + "name": "id", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "getOpenAcceptedBtcBuyOrders", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "tuple[]", + "internalType": "struct BtcMarketPlace.AcceptedBtcBuyOrder[]", + "components": [ + { + "name": "orderId", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "amountBtc", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "ercToken", + "type": "address", + "internalType": "address" + }, + { + "name": "ercAmount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "requester", + "type": "address", + "internalType": "address" + }, + { + "name": "accepter", + "type": "address", + "internalType": "address" + }, + { + "name": "acceptTime", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "", + "type": "uint256[]", + "internalType": "uint256[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getOpenAcceptedBtcSellOrders", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "tuple[]", + "internalType": "struct BtcMarketPlace.AcceptedBtcSellOrder[]", + "components": [ + { + "name": "orderId", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "bitcoinAddress", + "type": "tuple", + "internalType": "struct BtcMarketPlace.BitcoinAddress", + "components": [ + { + "name": "scriptPubKey", + "type": "bytes", + "internalType": "bytes" + } + ] + }, + { + "name": "amountBtc", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "ercToken", + "type": "address", + "internalType": "address" + }, + { + "name": "ercAmount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "requester", + "type": "address", + "internalType": "address" + }, + { + "name": "accepter", + "type": "address", + "internalType": "address" + }, + { + "name": "acceptTime", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "", + "type": "uint256[]", + "internalType": "uint256[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getOpenBtcBuyOrders", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "tuple[]", + "internalType": "struct BtcMarketPlace.BtcBuyOrder[]", + "components": [ + { + "name": "amountBtc", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "bitcoinAddress", + "type": "tuple", + "internalType": "struct BtcMarketPlace.BitcoinAddress", + "components": [ + { + "name": "scriptPubKey", + "type": "bytes", + "internalType": "bytes" + } + ] + }, + { + "name": "offeringToken", + "type": "address", + "internalType": "address" + }, + { + "name": "offeringAmount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "requester", + "type": "address", + "internalType": "address" + } + ] + }, + { + "name": "", + "type": "uint256[]", + "internalType": "uint256[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getOpenBtcSellOrders", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "tuple[]", + "internalType": "struct BtcMarketPlace.BtcSellOrder[]", + "components": [ + { + "name": "amountBtc", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "askingToken", + "type": "address", + "internalType": "address" + }, + { + "name": "askingAmount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "requester", + "type": "address", + "internalType": "address" + } + ] + }, + { + "name": "", + "type": "uint256[]", + "internalType": "uint256[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getTrustedForwarder", + "inputs": [], + "outputs": [ + { + "name": "forwarder", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isTrustedForwarder", + "inputs": [ + { + "name": "forwarder", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "placeBtcBuyOrder", + "inputs": [ + { + "name": "amountBtc", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "bitcoinAddress", + "type": "tuple", + "internalType": "struct BtcMarketPlace.BitcoinAddress", + "components": [ + { + "name": "scriptPubKey", + "type": "bytes", + "internalType": "bytes" + } + ] + }, + { + "name": "sellingToken", + "type": "address", + "internalType": "address" + }, + { + "name": "saleAmount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "placeBtcSellOrder", + "inputs": [ + { + "name": "amountBtc", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "buyingToken", + "type": "address", + "internalType": "address" + }, + { + "name": "buyAmount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "proofBtcBuyOrder", + "inputs": [ + { + "name": "id", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "transaction", + "type": "tuple", + "internalType": "struct BitcoinTx.Info", + "components": [ + { + "name": "version", + "type": "bytes4", + "internalType": "bytes4" + }, + { + "name": "inputVector", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "outputVector", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "locktime", + "type": "bytes4", + "internalType": "bytes4" + } + ] + }, + { + "name": "proof", + "type": "tuple", + "internalType": "struct BitcoinTx.Proof", + "components": [ + { + "name": "merkleProof", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "txIndexInBlock", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "bitcoinHeaders", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "coinbasePreimage", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "coinbaseProof", + "type": "bytes", + "internalType": "bytes" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "proofBtcSellOrder", + "inputs": [ + { + "name": "id", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "transaction", + "type": "tuple", + "internalType": "struct BitcoinTx.Info", + "components": [ + { + "name": "version", + "type": "bytes4", + "internalType": "bytes4" + }, + { + "name": "inputVector", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "outputVector", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "locktime", + "type": "bytes4", + "internalType": "bytes4" + } + ] + }, + { + "name": "proof", + "type": "tuple", + "internalType": "struct BitcoinTx.Proof", + "components": [ + { + "name": "merkleProof", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "txIndexInBlock", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "bitcoinHeaders", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "coinbasePreimage", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "coinbaseProof", + "type": "bytes", + "internalType": "bytes" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "withdrawBtcBuyOrder", + "inputs": [ + { + "name": "id", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "withdrawBtcSellOrder", + "inputs": [ + { + "name": "id", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "event", + "name": "acceptBtcBuyOrderEvent", + "inputs": [ + { + "name": "orderId", + "type": "uint256", + "indexed": true, + "internalType": "uint256" + }, + { + "name": "acceptId", + "type": "uint256", + "indexed": true, + "internalType": "uint256" + }, + { + "name": "amountBtc", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "ercAmount", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "ercToken", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "acceptBtcSellOrderEvent", + "inputs": [ + { + "name": "id", + "type": "uint256", + "indexed": true, + "internalType": "uint256" + }, + { + "name": "acceptId", + "type": "uint256", + "indexed": true, + "internalType": "uint256" + }, + { + "name": "bitcoinAddress", + "type": "tuple", + "indexed": false, + "internalType": "struct BtcMarketPlace.BitcoinAddress", + "components": [ + { + "name": "scriptPubKey", + "type": "bytes", + "internalType": "bytes" + } + ] + }, + { + "name": "amountBtc", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "ercAmount", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "ercToken", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "cancelAcceptedBtcBuyOrderEvent", + "inputs": [ + { + "name": "id", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "cancelAcceptedBtcSellOrderEvent", + "inputs": [ + { + "name": "id", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "placeBtcBuyOrderEvent", + "inputs": [ + { + "name": "amountBtc", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "bitcoinAddress", + "type": "tuple", + "indexed": false, + "internalType": "struct BtcMarketPlace.BitcoinAddress", + "components": [ + { + "name": "scriptPubKey", + "type": "bytes", + "internalType": "bytes" + } + ] + }, + { + "name": "sellingToken", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "saleAmount", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "placeBtcSellOrderEvent", + "inputs": [ + { + "name": "orderId", + "type": "uint256", + "indexed": true, + "internalType": "uint256" + }, + { + "name": "amountBtc", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "buyingToken", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "buyAmount", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "proofBtcBuyOrderEvent", + "inputs": [ + { + "name": "id", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "proofBtcSellOrderEvent", + "inputs": [ + { + "name": "id", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "withdrawBtcBuyOrderEvent", + "inputs": [ + { + "name": "id", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "withdrawBtcSellOrderEvent", + "inputs": [ + { + "name": "id", + "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 BtcMarketPlace { + use super::*; + use alloy::sol_types as 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[P`@QaE\xBA8\x03\x80aE\xBA\x839\x81\x01`@\x81\x90R`+\x91`\x81V[_\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x83\x16\x17\x90U`\x06\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x84\x16\x17\x90UPP`\x01`\x07U`\xB4V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14`~W__\xFD[PV[__`@\x83\x85\x03\x12\x15`\x91W__\xFD[\x82Q`\x9A\x81`kV[` \x84\x01Q\x90\x92P`\xA9\x81`kV[\x80\x91PP\x92P\x92\x90PV[aD\xF9\x80a\0\xC1_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01nW_5`\xE0\x1C\x80cj\x8C\xDE:\x11a\0\xD2W\x80c\xC5jE&\x11a\0\x88W\x80c\xDFi\xB1O\x11a\0cW\x80c\xDFi\xB1O\x14a\x03\xB2W\x80c\xEC\xCA,6\x14a\x03\xC5W\x80c\xFD?\xC2E\x14a\x042W__\xFD[\x80c\xC5jE&\x14a\x03|W\x80c\xCE\x1B\x81_\x14a\x03\x8FW\x80c\xD1\x92\x0F\xF0\x14a\x03\xA9W__\xFD[\x80c\xA3\x83\x01;\x11a\0\xB8W\x80c\xA3\x83\x01;\x14a\x02\xBAW\x80c\xB2#\xD9v\x14a\x02\xCDW\x80c\xBD*~>\x14a\x02\xE0W__\xFD[\x80cj\x8C\xDE:\x14a\x02\x8EW\x80c\x9C\xC6r.\x14a\x02\xA4W__\xFD[\x80cAEd\n\x11a\x01'W\x80cW+l\x05\x11a\x01\rW\x80cW+l\x05\x14a\x024W\x80c[\x8F\xE0B\x14a\x02eW\x80ch\x11\xA3\x11\x14a\x02xW__\xFD[\x80cAEd\n\x14a\x01\xFAW\x80cPj\x10\x9D\x14a\x02!W__\xFD[\x80c!\x0E\xC1\x81\x11a\x01WW\x80c!\x0E\xC1\x81\x14a\x01\xAEW\x80c6O\x1E\xC0\x14a\x01\xC1W\x80c:\xF3\xFC~\x14a\x01\xD6W__\xFD[\x80c\x11\xC17\xAA\x14a\x01rW\x80c\x1D\xFEu\x95\x14a\x01\x98W[__\xFD[a\x01\x85a\x01\x806`\x04a5OV[a\x04EV[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\x01\xA0a\x06>V[`@Qa\x01\x8F\x92\x91\x90a5\xEBV[a\x01\x85a\x01\xBC6`\x04a6\xD9V[a\x08\xA0V[a\x01\xD4a\x01\xCF6`\x04a7AV[a\n\xD7V[\0[a\x01\xE9a\x01\xE46`\x04a7\x9CV[a\x0C,V[`@Qa\x01\x8F\x95\x94\x93\x92\x91\x90a7\xB3V[a\x02\ra\x02\x086`\x04a7\x9CV[a\x0C\xFEV[`@Qa\x01\x8F\x98\x97\x96\x95\x94\x93\x92\x91\x90a7\xFBV[a\x01\xD4a\x02/6`\x04a7\x9CV[a\r\xEFV[a\x02Ua\x02B6`\x04a8PV[_T`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x91\x16\x14\x90V[`@Q\x90\x15\x15\x81R` \x01a\x01\x8FV[a\x01\xD4a\x02s6`\x04a8iV[a\x0E\xD4V[a\x02\x80a\x0F\xF0V[`@Qa\x01\x8F\x92\x91\x90a8\x9CV[a\x02\x96a\x11\xB4V[`@Qa\x01\x8F\x92\x91\x90a9+V[a\x02\xACa\x13\xBAV[`@Qa\x01\x8F\x92\x91\x90a9\xC3V[a\x01\xD4a\x02\xC86`\x04a7\x9CV[a\x16\x1DV[a\x01\xD4a\x02\xDB6`\x04a:\xB1V[a\x16\xC1V[a\x039a\x02\xEE6`\x04a7\x9CV[`\x02` \x81\x90R_\x91\x82R`@\x90\x91 \x80T`\x01\x82\x01T\x92\x82\x01T`\x03\x83\x01T`\x04\x84\x01T`\x05\x85\x01T`\x06\x90\x95\x01T\x93\x95\x94`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x94\x92\x93\x91\x82\x16\x92\x91\x16\x90\x87V[`@\x80Q\x97\x88R` \x88\x01\x96\x90\x96R`\x01`\x01`\xA0\x1B\x03\x94\x85\x16\x95\x87\x01\x95\x90\x95R``\x86\x01\x92\x90\x92R\x82\x16`\x80\x85\x01R\x16`\xA0\x83\x01R`\xC0\x82\x01R`\xE0\x01a\x01\x8FV[a\x01\xD4a\x03\x8A6`\x04a7\x9CV[a\x18]V[_T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01\x8FV[a\x01\x85aT`\x81V[a\x01\xD4a\x03\xC06`\x04a7\x9CV[a\x19@V[a\x04\x07a\x03\xD36`\x04a7\x9CV[`\x03` \x81\x90R_\x91\x82R`@\x90\x91 \x80T`\x01\x82\x01T`\x02\x83\x01T\x92\x90\x93\x01T\x90\x92`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x92\x91\x16\x84V[`@\x80Q\x94\x85R`\x01`\x01`\xA0\x1B\x03\x93\x84\x16` \x86\x01R\x84\x01\x91\x90\x91R\x16``\x82\x01R`\x80\x01a\x01\x8FV[a\x01\xD4a\x04@6`\x04a:\xB1V[a\x1ASV[_\x82\x81R`\x01` R`@\x81 \x80T\x83\x11\x15a\x04_W__\xFD[_\x83\x11a\x04jW__\xFD[\x80T`\x03\x82\x01T_\x91\x90a\x04~\x90\x86a;UV[a\x04\x88\x91\x90a;\x99V[\x90P_\x81\x11a\x04\x99Wa\x04\x99a;\xACV[\x80\x82`\x03\x01T\x10\x15a\x04\xADWa\x04\xADa;\xACV[\x80\x82`\x03\x01_\x82\x82Ta\x04\xC0\x91\x90a;\xD9V[\x90\x91UPP\x81T\x84\x90\x83\x90_\x90a\x04\xD8\x90\x84\x90a;\xD9V[\x90\x91UPP`@\x80Q`\xE0\x81\x01\x82R\x86\x81R` \x81\x01\x86\x90R`\x02\x84\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x92\x82\x01\x92\x90\x92R``\x81\x01\x83\x90R`\x04\x84\x01T\x90\x91\x16`\x80\x82\x01R_\x90`\xA0\x81\x01a\x05*a\x1B\xE0V[`\x01`\x01`\xA0\x1B\x03\x16\x81RB` \x90\x91\x01R`\x05\x80T\x91\x92P_\x91\x90\x82a\x05P\x83a;\xECV[\x90\x91UP_\x81\x81R`\x02` \x81\x81R`@\x92\x83\x90 \x86Q\x81U\x86\x82\x01Q`\x01\x82\x01U\x86\x84\x01Q\x81\x84\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x17\x90\x91U``\x80\x8A\x01Q`\x03\x85\x01U`\x80\x8A\x01Q`\x04\x85\x01\x80T\x84\x16\x91\x85\x16\x91\x90\x91\x17\x90U`\xA0\x8A\x01Q`\x05\x85\x01\x80T\x90\x93\x16\x90\x84\x16\x17\x90\x91U`\xC0\x89\x01Q`\x06\x90\x93\x01\x92\x90\x92U\x92\x89\x01T\x84Q\x8C\x81R\x92\x83\x01\x89\x90R\x90\x92\x16\x92\x81\x01\x92\x90\x92R\x91\x92P\x82\x91\x89\x91\x7F\xC3\x9A\x1A]\xDC\x0E\x85\xC9U\xFE.\x1A\xBE\xB4<\x94\xCE\x182.u\xBB=D\xE8\x0Fu\x9F\xF9\xD04\xB9\x91\x01`@Q\x80\x91\x03\x90\xA3\x93PPPP[\x92\x91PPV[``\x80_\x80[`\x05T\x81\x10\x15a\x06\x83W_\x81\x81R`\x01` R`@\x90 `\x04\x01T`\x01`\x01`\xA0\x1B\x03\x16\x15a\x06{W\x81a\x06w\x81a;\xECV[\x92PP[`\x01\x01a\x06DV[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\x9EWa\x06\x9Ea<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x06\xD7W\x81` \x01[a\x06\xC4a4eV[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x06\xBCW\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\xF4Wa\x06\xF4a<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x07\x1DW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x05T\x81\x10\x15a\x08\x94W_\x81\x81R`\x01` R`@\x90 `\x04\x01T`\x01`\x01`\xA0\x1B\x03\x16\x15a\x08\x8CW`\x01_\x82\x81R` \x01\x90\x81R` \x01_ `@Q\x80`\xA0\x01`@R\x90\x81_\x82\x01T\x81R` \x01`\x01\x82\x01`@Q\x80` \x01`@R\x90\x81_\x82\x01\x80Ta\x07\x90\x90a<1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07\xBC\x90a<1V[\x80\x15a\x08\x07W\x80`\x1F\x10a\x07\xDEWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x08\x07V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\xEAW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP\x81R`\x02\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16` \x83\x01R`\x03\x83\x01T`@\x83\x01R`\x04\x90\x92\x01T\x90\x91\x16``\x90\x91\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x08UWa\x08Ua<|V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x08sWa\x08sa<|V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x08\x88\x81a;\xECV[\x92PP[`\x01\x01a\x07#V[P\x91\x95\x90\x94P\x92PPPV[_\x83\x81R`\x03` R`@\x81 \x82a\x08\xB6W__\xFD[\x80T\x83\x11\x15a\x08\xC3W__\xFD[\x80T`\x02\x82\x01T_\x91\x90a\x08\xD7\x90\x86a;UV[a\x08\xE1\x91\x90a;\x99V[\x90P_\x81\x11a\x08\xF2Wa\x08\xF2a;\xACV[\x80\x82`\x02\x01T\x10\x15a\t\x06Wa\t\x06a;\xACV[\x80\x82`\x02\x01_\x82\x82Ta\t\x19\x91\x90a;\xD9V[\x90\x91UPP\x81T\x84\x90\x83\x90_\x90a\t1\x90\x84\x90a;\xD9V[\x90\x91UPa\tX\x90Pa\tBa\x1B\xE0V[`\x01\x84\x01T`\x01`\x01`\xA0\x1B\x03\x16\x900\x84a\x1C0V[`\x05\x80T_\x91\x82a\th\x83a;\xECV[\x91\x90PU\x90P`@Q\x80a\x01\0\x01`@R\x80\x88\x81R` \x01\x87a\t\x8A\x90a=]V[\x81R` \x81\x01\x87\x90R`\x01\x85\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`@\x83\x01R``\x82\x01\x85\x90R`\x03\x86\x01T\x16`\x80\x82\x01R`\xA0\x01a\t\xC5a\x1B\xE0V[`\x01`\x01`\xA0\x1B\x03\x16\x81RB` \x91\x82\x01R_\x83\x81R`\x04\x82R`@\x90 \x82Q\x81U\x90\x82\x01Q\x80Q`\x01\x83\x01\x90\x81\x90a\t\xFE\x90\x82a>\x02V[PPP`@\x82\x81\x01Q`\x02\x83\x01U``\x83\x01Q`\x03\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x17\x90\x91U`\x80\x85\x01Q`\x04\x85\x01U`\xA0\x85\x01Q`\x05\x85\x01\x80T\x83\x16\x91\x84\x16\x91\x90\x91\x17\x90U`\xC0\x85\x01Q`\x06\x85\x01\x80T\x90\x92\x16\x90\x83\x16\x17\x90U`\xE0\x90\x93\x01Q`\x07\x90\x92\x01\x91\x90\x91U`\x01\x85\x01T\x90Q\x83\x92\x8A\x92\x7Fe>\r\x81\xF2\xC9\x9B\xEB\xA3Y\xDF\xB1{I\x9A\\\xFF+\xE9\xD9PQHR\"M\xF8\xC0\x97\xC2\x19!\x92a\n\xC3\x92\x8C\x92\x8C\x92\x8A\x92\x91\x90\x91\x16\x90a?TV[`@Q\x80\x91\x03\x90\xA3\x92PPP[\x93\x92PPPV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\n\xE9W__\xFD[a\x0B\x06a\n\xF4a\x1B\xE0V[`\x01`\x01`\xA0\x1B\x03\x84\x16\x900\x84a\x1C0V[`\x05\x80T_\x91\x82a\x0B\x16\x83a;\xECV[\x91\x90PU\x90P`@Q\x80`\xA0\x01`@R\x80\x86\x81R` \x01\x85a\x0B7\x90a=]V[\x81R` \x01\x84`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x83\x81R` \x01a\x0BYa\x1B\xE0V[`\x01`\x01`\xA0\x1B\x03\x16\x90R_\x82\x81R`\x01` \x81\x81R`@\x90\x92 \x83Q\x81U\x91\x83\x01Q\x80Q\x90\x91\x83\x01\x90\x81\x90a\x0B\x8F\x90\x82a>\x02V[PPP`@\x82\x81\x01Q`\x02\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x17\x90\x91U``\x85\x01Q`\x03\x85\x01U`\x80\x90\x94\x01Q`\x04\x90\x93\x01\x80T\x90\x94\x16\x92\x16\x91\x90\x91\x17\x90\x91UQ\x7F\x98\xC7\xC6\x80@=G@=\xEAJW\r\x0ElW\x16S\x8CIB\x0E\xF4q\xCE\xC4(\xF5\xA5\x85,\x06\x90a\x0C\x1D\x90\x87\x90\x87\x90\x87\x90\x87\x90a?\x8BV[`@Q\x80\x91\x03\x90\xA1PPPPPV[`\x01` \x81\x81R_\x92\x83R`@\x92\x83\x90 \x80T\x84Q\x92\x83\x01\x90\x94R\x91\x82\x01\x80T\x82\x90\x82\x90a\x0CY\x90a<1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C\x85\x90a<1V[\x80\x15a\x0C\xD0W\x80`\x1F\x10a\x0C\xA7Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C\xD0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0C\xB3W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP`\x02\x82\x01T`\x03\x83\x01T`\x04\x90\x93\x01T\x91\x92`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x92\x90\x91\x16\x85V[`\x04` R\x80_R`@_ _\x91P\x90P\x80_\x01T\x90\x80`\x01\x01`@Q\x80` \x01`@R\x90\x81_\x82\x01\x80Ta\r2\x90a<1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r^\x90a<1V[\x80\x15a\r\xA9W\x80`\x1F\x10a\r\x80Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\r\xA9V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r\x8CW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP`\x02\x82\x01T`\x03\x83\x01T`\x04\x84\x01T`\x05\x85\x01T`\x06\x86\x01T`\x07\x90\x96\x01T\x94\x95\x93\x94`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x94\x92\x93\x91\x82\x16\x92\x90\x91\x16\x90\x88V[_\x81\x81R`\x01` R`@\x90 a\x0E\x04a\x1B\xE0V[`\x04\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x0E\x1FW__\xFD[a\x0EDa\x0E*a\x1B\xE0V[`\x03\x83\x01T`\x02\x84\x01T`\x01`\x01`\xA0\x1B\x03\x16\x91\x90a\x1C\xE7V[_\x82\x81R`\x01` \x81\x90R`@\x82 \x82\x81U\x91\x90\x82\x01\x81a\x0Ee\x82\x82a4\xA6V[PPP`\x02\x81\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U_`\x03\x83\x01U`\x04\x90\x91\x01\x80T\x90\x91\x16\x90U`@Q\x82\x81R\x7F\xC3@\xE7\xACH\xDC\x80\xEEy?\xC6&i`\xBD_\x1B\xD2\x1B\xE9\x1C\x8A\x95\xE2\x18\x17\x81\x13\xF7\x9E\x17\xB4\x90` \x01[`@Q\x80\x91\x03\x90\xA1PPV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x0E\xE6W__\xFD[_\x83\x11a\x0E\xF1W__\xFD[_\x81\x11a\x0E\xFCW__\xFD[`\x05\x80T_\x91\x82a\x0F\x0C\x83a;\xECV[\x91\x90PU\x90P`@Q\x80`\x80\x01`@R\x80\x85\x81R` \x01\x84`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x83\x81R` \x01a\x0F@a\x1B\xE0V[`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x90\x91R_\x83\x81R`\x03` \x81\x81R`@\x92\x83\x90 \x85Q\x81U\x85\x82\x01Q`\x01\x82\x01\x80T\x91\x87\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x92\x83\x16\x17\x90U\x86\x85\x01Q`\x02\x83\x01U``\x96\x87\x01Q\x91\x90\x93\x01\x80T\x91\x86\x16\x91\x90\x93\x16\x17\x90\x91U\x81Q\x88\x81R\x92\x87\x16\x90\x83\x01R\x81\x01\x84\x90R\x82\x91\x7F\xFF\x1C\xE2\x10\xDE\xFC\xD3\xBA\x1A\xDFv\xC9A\x9A\x07X\xFA`\xFD>\xB3\x8C{\xD9A\x8F`\xB5u\xB7n$\x91\x01`@Q\x80\x91\x03\x90\xA2PPPPV[``\x80_\x80[`\x05T\x81\x10\x15a\x106W_\x81\x81R`\x03` \x81\x90R`@\x90\x91 \x01T`\x01`\x01`\xA0\x1B\x03\x16\x15a\x10.W\x81a\x10*\x81a;\xECV[\x92PP[`\x01\x01a\x0F\xF6V[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10QWa\x10Qa<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x10\xA1W\x81` \x01[`@\x80Q`\x80\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x92\x82\x01\x81\x90R``\x82\x01R\x82R_\x19\x90\x92\x01\x91\x01\x81a\x10oW\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10\xBEWa\x10\xBEa<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x10\xE7W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x05T\x81\x10\x15a\x08\x94W_\x81\x81R`\x03` \x81\x90R`@\x90\x91 \x01T`\x01`\x01`\xA0\x1B\x03\x16\x15a\x11\xACW_\x81\x81R`\x03` \x81\x81R`@\x92\x83\x90 \x83Q`\x80\x81\x01\x85R\x81T\x81R`\x01\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x93\x82\x01\x93\x90\x93R`\x02\x82\x01T\x94\x81\x01\x94\x90\x94R\x90\x91\x01T\x16``\x82\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x11uWa\x11ua<|V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x11\x93Wa\x11\x93a<|V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x11\xA8\x81a;\xECV[\x92PP[`\x01\x01a\x10\xEDV[``\x80_\x80[`\x05T\x81\x10\x15a\x11\xF0W_\x81\x81R`\x02` R`@\x90 `\x01\x01T\x15a\x11\xE8W\x81a\x11\xE4\x81a;\xECV[\x92PP[`\x01\x01a\x11\xBAV[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\x0BWa\x12\x0Ba<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x12\x90W\x81` \x01[a\x12}`@Q\x80`\xE0\x01`@R\x80_\x81R` \x01_\x81R` \x01_`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01_\x81R` \x01_`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01_`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01_\x81RP\x90V[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x12)W\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\xADWa\x12\xADa<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x12\xD6W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x05T\x81\x10\x15a\x08\x94W_\x81\x81R`\x02` R`@\x90 `\x01\x01T\x15a\x13\xB2W_\x81\x81R`\x02` \x81\x81R`@\x92\x83\x90 \x83Q`\xE0\x81\x01\x85R\x81T\x81R`\x01\x82\x01T\x92\x81\x01\x92\x90\x92R\x91\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x93\x82\x01\x93\x90\x93R`\x03\x82\x01T``\x82\x01R`\x04\x82\x01T\x83\x16`\x80\x82\x01R`\x05\x82\x01T\x90\x92\x16`\xA0\x83\x01R`\x06\x01T`\xC0\x82\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x13{Wa\x13{a<|V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x13\x99Wa\x13\x99a<|V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x13\xAE\x81a;\xECV[\x92PP[`\x01\x01a\x12\xDCV[``\x80_\x80[`\x05T\x81\x10\x15a\x13\xF6W_\x81\x81R`\x04` R`@\x90 `\x02\x01T\x15a\x13\xEEW\x81a\x13\xEA\x81a;\xECV[\x92PP[`\x01\x01a\x13\xC0V[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x14\x11Wa\x14\x11a<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x14JW\x81` \x01[a\x147a4\xE0V[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x14/W\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x14gWa\x14ga<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x14\x90W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x05T\x81\x10\x15a\x08\x94W_\x81\x81R`\x04` R`@\x90 `\x02\x01T\x15a\x16\x15W`\x04_\x82\x81R` \x01\x90\x81R` \x01_ `@Q\x80a\x01\0\x01`@R\x90\x81_\x82\x01T\x81R` \x01`\x01\x82\x01`@Q\x80` \x01`@R\x90\x81_\x82\x01\x80Ta\x14\xFB\x90a<1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x15'\x90a<1V[\x80\x15a\x15rW\x80`\x1F\x10a\x15IWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x15rV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15UW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP\x81R`\x02\x82\x01T` \x82\x01R`\x03\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`@\x83\x01R`\x04\x83\x01T``\x83\x01R`\x05\x83\x01T\x81\x16`\x80\x83\x01R`\x06\x83\x01T\x16`\xA0\x82\x01R`\x07\x90\x91\x01T`\xC0\x90\x91\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x15\xDEWa\x15\xDEa<|V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x15\xFCWa\x15\xFCa<|V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x16\x11\x81a;\xECV[\x92PP[`\x01\x01a\x14\x96V[_\x81\x81R`\x03` R`@\x90 a\x162a\x1B\xE0V[`\x03\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x16MW__\xFD[_\x82\x81R`\x03` \x81\x81R`@\x80\x84 \x84\x81U`\x01\x81\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U`\x02\x82\x01\x95\x90\x95U\x90\x92\x01\x80T\x90\x93\x16\x90\x92UQ\x83\x81R\x7F<\xD4u\xB0\x92\xE8\xB3y\xF6\xBA\r\x9E\x0E\x0C\x8F0p^s2\x1D\xC5\xC9\xF8\x0C\xE4\xAD8\xDB{\xE1\xAA\x91\x01a\x0E\xC8V[_\x83\x81R`\x02` R`@\x90 a\x16\xD6a\x1B\xE0V[`\x05\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x16\xF1W__\xFD[`\x06T`\x01`\x01`\xA0\x1B\x03\x16c\xD3\x8C)\xA1a\x17\x0F`@\x85\x01\x85a?\xBFV[`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x17,\x92\x91\x90a@ V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x17CW__\xFD[PZ\xF1\x15\x80\x15a\x17UW=__>=_\xFD[PPPPa\x17\x86`\x07T\x84a\x17i\x90a@bV[a\x17r\x85aA\x10V[`\x06T`\x01`\x01`\xA0\x1B\x03\x16\x92\x91\x90a\x1D5V[P\x80T_\x90\x81R`\x01` \x81\x90R`@\x90\x91 \x80T\x90\x91a\x17\xAA\x91\x90\x83\x01\x86a\x1DbV[`\x05\x82\x01T`\x03\x83\x01T`\x02\x84\x01Ta\x17\xD1\x92`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x92\x91\x16\x90a\x1C\xE7V[_\x85\x81R`\x02` \x81\x81R`@\x80\x84 \x84\x81U`\x01\x81\x01\x85\x90U\x92\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U`\x03\x84\x01\x85\x90U`\x04\x84\x01\x80T\x82\x16\x90U`\x05\x84\x01\x80T\x90\x91\x16\x90U`\x06\x90\x92\x01\x92\x90\x92UQ\x86\x81R\x7F\xB4\xC9\x8D\xE2\x10ik<\xF2\x1E\x993\\\x1E\xE3\xA0\xAE4\xA2g\x13A*J\xDD\xE8\xAFYav\xF3~\x91\x01a\x0C\x1DV[_\x81\x81R`\x02` R`@\x90 a\x18ra\x1B\xE0V[`\x04\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x18\x8DW__\xFD[aT`\x81`\x06\x01Ta\x18\x9F\x91\x90aA\xBDV[B\x11a\x18\xA9W__\xFD[a\x18\xB4a\x0E*a\x1B\xE0V[_\x82\x81R`\x02` \x81\x81R`@\x80\x84 \x84\x81U`\x01\x81\x01\x85\x90U\x92\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U`\x03\x84\x01\x85\x90U`\x04\x84\x01\x80T\x82\x16\x90U`\x05\x84\x01\x80T\x90\x91\x16\x90U`\x06\x90\x92\x01\x92\x90\x92UQ\x83\x81R\x7F>^\xA3X\xE9\xEBL\xDFD\xCD\xC7y8\xAD\xE8\x07K\x12@\xA6\xD8\xC0\xFD\x13r\x86q\xB8.\x80\n\xD6\x91\x01a\x0E\xC8V[_\x81\x81R`\x04` R`@\x90 `\x07\x81\x01Ta\x19_\x90aT`\x90aA\xBDV[B\x11a\x19iW__\xFD[a\x19qa\x1B\xE0V[`\x06\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x19\x8CW__\xFD[a\x19\xB1a\x19\x97a\x1B\xE0V[`\x04\x83\x01T`\x03\x84\x01T`\x01`\x01`\xA0\x1B\x03\x16\x91\x90a\x1C\xE7V[_\x82\x81R`\x04` R`@\x81 \x81\x81U\x90`\x01\x82\x01\x81a\x19\xD1\x82\x82a4\xA6V[PP_`\x02\x83\x01\x81\x90U`\x03\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U`\x04\x84\x01\x82\x90U`\x05\x84\x01\x80T\x82\x16\x90U`\x06\x84\x01\x80T\x90\x91\x16\x90U`\x07\x90\x92\x01\x91\x90\x91UP`@Q\x82\x81R\x7Fx\xF5\x1Fb\xF7\xCF\x13\x81\xC6s\xC2~\xAE\x18}\xD6\xC5\x88\xDCf$\xCEYi}\xBB>\x1D|\x1B\xBC\xDF\x90` \x01a\x0E\xC8V[_\x83\x81R`\x04` R`@\x90 a\x1Aha\x1B\xE0V[`\x05\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x1A\x83W__\xFD[`\x06T`\x01`\x01`\xA0\x1B\x03\x16c\xD3\x8C)\xA1a\x1A\xA1`@\x85\x01\x85a?\xBFV[`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1A\xBE\x92\x91\x90a@ V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1A\xD5W__\xFD[PZ\xF1\x15\x80\x15a\x1A\xE7W=__>=_\xFD[PPPPa\x1A\xFB`\x07T\x84a\x17i\x90a@bV[Pa\x1B\x0E\x81`\x02\x01T\x82`\x01\x01\x85a\x1DbV[`\x05\x81\x01T`\x04\x82\x01T`\x03\x83\x01Ta\x1B5\x92`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x92\x91\x16\x90a\x1C\xE7V[_\x84\x81R`\x04` R`@\x81 \x81\x81U\x90`\x01\x82\x01\x81a\x1BU\x82\x82a4\xA6V[PP_`\x02\x83\x01\x81\x90U`\x03\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U`\x04\x84\x01\x82\x90U`\x05\x84\x01\x80T\x82\x16\x90U`\x06\x84\x01\x80T\x90\x91\x16\x90U`\x07\x90\x92\x01\x91\x90\x91UP`@Q\x84\x81R\x7F\xCFV\x10a\xDBx\xF7\xBCQ\x8D7\xFE\x86q\x85\x14\xC6@\xCC\xC5\xC3\xF1)8(\xB9U\xE6\x8F\x19\xF5\xFB\x90` \x01`@Q\x80\x91\x03\x90\xA1PPPPV[_`\x146\x10\x80\x15\x90a\x1B\xFBWP_T`\x01`\x01`\xA0\x1B\x03\x163\x14[\x15a\x1C+WP\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xEC6\x015``\x1C\x90V[P3\x90V[`@Q`\x01`\x01`\xA0\x1B\x03\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x1C\xE1\x90\x85\x90\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\x90`\x84\x01[`@\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\x1EyV[PPPPV[`@Q`\x01`\x01`\xA0\x1B\x03\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x1D0\x90\x84\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\x90`d\x01a\x1C}V[PPPV[_a\x1D?\x83a\x1F]V[\x90Pa\x1DK\x81\x83a MV[a\x1DZ\x85\x85\x84`@\x01Qa\"\xB1V[\x94\x93PPPPV[_\x82_\x01\x80Ta\x1Dq\x90a<1V[`@Qa\x1D\x83\x92P\x85\x90` \x01aA\xD0V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P_a\x1D\xEA\x83\x80`@\x01\x90a\x1D\xAF\x91\x90a?\xBFV[\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\x91RP\x86\x92Pa&\x01\x91PPV[Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x84\x81\x10\x15a\x1ErW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`;`$\x82\x01R\x7FBitcoin transaction amount is lo`D\x82\x01R\x7Fwer than in accepted order.\0\0\0\0\0`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[PPPPPV[_a\x1E\xCD\x82`@Q\x80`@\x01`@R\x80` \x81R` \x01\x7FSafeERC20: low-level call failed\x81RP\x85`\x01`\x01`\xA0\x1B\x03\x16a'\x9F\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x1D0W\x80\x80` \x01\x90Q\x81\x01\x90a\x1E\xEB\x91\x90aB\x97V[a\x1D0W`@QbF\x1B\xCD`\xE5\x1B\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\x1EiV[_a\x1Fk\x82` \x01Qa'\xADV[a\x1F\xB7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FInvalid input vector provided\0\0\0`D\x82\x01R`d\x01a\x1EiV[a\x1F\xC4\x82`@\x01Qa(GV[a \x10W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FInvalid output vector provided\0\0`D\x82\x01R`d\x01a\x1EiV[a\x068\x82_\x01Q\x83` \x01Q\x84`@\x01Q\x85``\x01Q`@Q` \x01a 9\x94\x93\x92\x91\x90aB\xCDV[`@Q` \x81\x83\x03\x03\x81R\x90`@Ra(\xD4V[\x80Qa X\x90a(\xF6V[a \xA4W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7FBad merkle array proof\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x1EiV[`\x80\x81\x01QQ\x81QQ\x14a! W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`/`$\x82\x01R\x7FTx not on same level of merkle t`D\x82\x01R\x7Free as coinbase\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x1EiV[_a!.\x82`@\x01Qa)\x0CV[\x82Q` \x84\x01Q\x91\x92Pa!E\x91\x85\x91\x84\x91a)\x18V[a!\xB7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`<`$\x82\x01R\x7FTx merkle proof is not valid for`D\x82\x01R\x7F provided header and tx hash\0\0\0\0`d\x82\x01R`\x84\x01a\x1EiV[_`\x02\x83``\x01Q`@Q` \x01a!\xD1\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra!\xEB\x91aC=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\")\x91\x90aCGV[`\x80\x84\x01Q\x90\x91Pa\"?\x90\x82\x90\x84\x90_a)\x18V[a\x1C\xE1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`?`$\x82\x01R\x7FCoinbase merkle proof is not val`D\x82\x01R\x7Fid for provided header and hash\0`d\x82\x01R`\x84\x01a\x1EiV[_\x83`\x01`\x01`\xA0\x1B\x03\x16c\x117d\xBE`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\"\xEEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a#\x12\x91\x90aCGV[\x90P_\x84`\x01`\x01`\xA0\x1B\x03\x16c+\x97\xBE$`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a#QW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a#u\x91\x90aCGV[\x90P_\x80a#\x8Aa#\x85\x86a)SV[a)^V[\x90P\x83\x81\x03a#\x9BW\x83\x91Pa$\x18V[\x82\x81\x03a#\xAAW\x82\x91Pa$\x18V[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`%`$\x82\x01R\x7FNot at current or previous diffi`D\x82\x01R\x7Fculty\0\0\0\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\x1EiV[_a$\"\x86a)\x85V[\x90P_\x19\x81\x03a$\x9AW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`#`$\x82\x01R\x7FInvalid length of the headers ch`D\x82\x01R\x7Fain\0\0\0\0\0\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\x1EiV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81\x03a%\tW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FInvalid headers chain\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x1EiV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFD\x81\x03a%xW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FInsufficient work in a header\0\0\0`D\x82\x01R`d\x01a\x1EiV[a%\x82\x87\x84a;UV[\x81\x10\x15a%\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FInsufficient accumulated difficu`D\x82\x01R\x7Flty in header chain\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x1EiV[PPPPPPPPV[`@\x80Q``\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x82\x84\x01\x82\x90R\x83Q\x80\x85\x01\x90\x94R\x81\x84R\x83\x01R\x90a&5\x84a+\xA9V[` \x83\x01R\x80\x82R\x81a&G\x82a;\xECV[\x90RP_\x80[\x82` \x01Q\x81\x10\x15a'IW\x82Q_\x90a&h\x90\x88\x90a+\xBEV[\x84Q\x90\x91P_\x90a&z\x90\x89\x90a,\x1EV[\x90P_a&\x88`\x08\x84a;\xD9V[\x86Q\x90\x91P_\x90a&\x9A\x90`\x08aA\xBDV[\x8A\x81\x01` \x01\x83\x90 \x90\x91P\x80\x8A\x03a&\xD4W`\x01\x96P\x83\x89_\x01\x81\x81Qa&\xC2\x91\x90aC^V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RPa'$V[_a&\xE2\x8C\x8A_\x01Qa,\x94V[\x90P`\x01`\x01`\xA0\x1B\x03\x81\x16\x15a'\x03W`\x01`\x01`\xA0\x1B\x03\x81\x16` \x8B\x01R[_a'\x11\x8D\x8B_\x01Qa-tV[\x90P\x80\x15a'!W`@\x8B\x01\x81\x90R[PP[\x84\x88_\x01\x81\x81Qa'5\x91\x90aA\xBDV[\x90RPP`\x01\x90\x94\x01\x93Pa&M\x92PPPV[P\x80a'\x97W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FNo output found for scriptPubKey`D\x82\x01R`d\x01a\x1EiV[PP\x92\x91PPV[``a\x1DZ\x84\x84_\x85a.TV[___a'\xB9\x84a+\xA9V[\x90\x92P\x90P\x80\x15\x80a'\xCBWP_\x19\x82\x14[\x15a'\xD9WP_\x93\x92PPPV[_a'\xE5\x83`\x01aA\xBDV[\x90P_[\x82\x81\x10\x15a(:W\x85Q\x82\x10a(\x04WP_\x95\x94PPPPPV[_a(\x0F\x87\x84a/\x98V[\x90P_\x19\x81\x03a(%WP_\x96\x95PPPPPPV[a(/\x81\x84aA\xBDV[\x92PP`\x01\x01a'\xE9V[P\x93Q\x90\x93\x14\x93\x92PPPV[___a(S\x84a+\xA9V[\x90\x92P\x90P\x80\x15\x80a(eWP_\x19\x82\x14[\x15a(sWP_\x93\x92PPPV[_a(\x7F\x83`\x01aA\xBDV[\x90P_[\x82\x81\x10\x15a(:W\x85Q\x82\x10a(\x9EWP_\x95\x94PPPPPV[_a(\xA9\x87\x84a+\xBEV[\x90P_\x19\x81\x03a(\xBFWP_\x96\x95PPPPPPV[a(\xC9\x81\x84aA\xBDV[\x92PP`\x01\x01a(\x83V[_` _\x83Q` \x85\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x91\x90PV[_` \x82Qa)\x05\x91\x90aC~V[\x15\x92\x91PPV[`D\x81\x01Q_\x90a\x068V[_\x83\x85\x14\x80\x15a)&WP\x81\x15[\x80\x15a)1WP\x82Q\x15[\x15a)>WP`\x01a\x1DZV[a)J\x85\x84\x86\x85a/\xDEV[\x95\x94PPPPPV[_a\x068\x82_a0\x83V[_a\x068{\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\x83a1\x1CV[_`P\x82Qa)\x94\x91\x90aC~V[\x15a)\xA1WP_\x19\x91\x90PV[P_\x80\x80[\x83Q\x81\x10\x15a+\xA2W\x80\x15a)\xEDWa)\xC0\x84\x82\x84a1'V[a)\xEDWP\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x93\x92PPPV[_a)\xF8\x85\x83a0\x83V[\x90Pa*\x06\x85\x83`Pa1PV[\x92P\x80a+I\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a+yWP\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFD\x94\x93PPPPV[a+\x82\x81a)^V[a+\x8C\x90\x85aA\xBDV[\x93Pa+\x9B\x90P`P\x82aA\xBDV[\x90Pa)\xA6V[PP\x91\x90PV[__a+\xB5\x83_a1uV[\x91P\x91P\x91P\x91V[_a+\xCA\x82`\taA\xBDV[\x83Q\x10\x15a+\xDAWP_\x19a\x068V[_\x80a+\xF0\x85a+\xEB\x86`\x08aA\xBDV[a1uV[\x90\x92P\x90P`\x01\x82\x01a,\x08W_\x19\x92PPPa\x068V[\x80a,\x14\x83`\taA\xBDV[a)J\x91\x90aA\xBDV[_\x80a,*\x84\x84a3\x12V[`\xC0\x1C\x90P_a)J\x82d\xFF\0\0\0\xFF`\x08\x82\x81\x1C\x91\x82\x16e\xFF\0\0\0\xFF\0\x93\x90\x91\x1B\x92\x83\x16\x17`\x10\x90\x81\x1Bg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16f\xFF\0\xFF\0\xFF\0\xFF\x92\x90\x92\x16g\xFF\0\xFF\0\xFF\0\xFF\0\x90\x93\x16\x92\x90\x92\x17\x90\x91\x1Ce\xFF\xFF\0\0\xFF\xFF\x16\x17` \x81\x81\x1C\x91\x90\x1B\x17\x90V[_\x82a,\xA1\x83`\taA\xBDV[\x81Q\x81\x10a,\xB1Wa,\xB1a<|V[` \x91\x01\x01Q\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\x16\x7Fj\0\0\0\0\0\0\0\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-\x06WP_a\x068V[_\x83a-\x13\x84`\naA\xBDV[\x81Q\x81\x10a-#Wa-#a<|V[\x01` \x01Q\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\x81\x16\x91P`\xF8\x1C`\x14\x03a-mW_a-c\x84`\x0BaA\xBDV[\x85\x01`\x14\x01Q\x92PP[P\x92\x91PPV[_\x82a-\x81\x83`\taA\xBDV[\x81Q\x81\x10a-\x91Wa-\x91a<|V[` \x91\x01\x01Q\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\x16\x7Fj\0\0\0\0\0\0\0\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-\xE6WP_a\x068V[_\x83a-\xF3\x84`\naA\xBDV[\x81Q\x81\x10a.\x03Wa.\x03a<|V[\x01` \x90\x81\x01Q\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\x81\x16\x92P`\xF8\x1C\x90\x03a-mW_a.D\x84`\x0BaA\xBDV[\x85\x01` \x01Q\x92PPP\x92\x91PPV[``\x82G\x10\x15a.\xCCW`@QbF\x1B\xCD`\xE5\x1B\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\x1EiV[`\x01`\x01`\xA0\x1B\x03\x85\x16;a/#W`@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\x1EiV[__\x86`\x01`\x01`\xA0\x1B\x03\x16\x85\x87`@Qa/>\x91\x90aCa/}V[``\x91P[P\x91P\x91Pa/\x8D\x82\x82\x86a3 V[\x97\x96PPPPPPPV[___a/\xA5\x85\x85a3YV[\x90\x92P\x90P`\x01\x82\x01a/\xBDW_\x19\x92PPPa\x068V[\x80a/\xC9\x83`%aA\xBDV[a/\xD3\x91\x90aA\xBDV[a)J\x90`\x04aA\xBDV[_` \x84Qa/\xED\x91\x90aC~V[\x15a/\xF9WP_a\x1DZV[\x83Q_\x03a0\x08WP_a\x1DZV[\x81\x85_[\x86Q\x81\x10\x15a0vWa0 `\x02\x84aC~V[`\x01\x03a0DWa0=a07\x88\x83\x01` \x01Q\x90V[\x83a3\x97V[\x91Pa0]V[a0Z\x82a0U\x89\x84\x01` \x01Q\x90V[a3\x97V[\x91P[`\x01\x92\x90\x92\x1C\x91a0o` \x82aA\xBDV[\x90Pa0\x0CV[P\x90\x93\x14\x95\x94PPPPPV[_\x80a0\x9Aa0\x93\x84`HaA\xBDV[\x85\x90a3\x12V[`\xE8\x1C\x90P_\x84a0\xAC\x85`KaA\xBDV[\x81Q\x81\x10a0\xBCWa0\xBCa<|V[\x01` \x01Q`\xF8\x1C\x90P_a0\xEE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a1\x01`\x03\x84aC\x91V[`\xFF\x16\x90Pa1\x12\x81a\x01\0aD\x8DV[a/\x8D\x90\x83a;UV[_a\n\xD0\x82\x84a;\x99V[_\x80a13\x85\x85a3\xA2V[\x90P\x82\x81\x14a1EW_\x91PPa\n\xD0V[P`\x01\x94\x93PPPPV[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[___a1\x82\x85\x85a3\xBAV[\x90P\x80`\xFF\x16_\x03a1\xB5W_\x85\x85\x81Q\x81\x10a1\xA1Wa1\xA1a<|V[\x01` \x01Q\x90\x93P`\xF8\x1C\x91Pa3\x0B\x90PV[\x83a1\xC1\x82`\x01aD\x98V[`\xFF\x16a1\xCE\x91\x90aA\xBDV[\x85Q\x10\x15a1\xE3W_\x19_\x92P\x92PPa3\x0BV[_\x81`\xFF\x16`\x02\x03a2&Wa2\x1Ba2\x07a2\0\x87`\x01aA\xBDV[\x88\x90a3\x12V[b\xFF\xFF\0`\xE8\x82\x90\x1C\x16`\xF8\x91\x90\x91\x1C\x17\x90V[a\xFF\xFF\x16\x90Pa3\x01V[\x81`\xFF\x16`\x04\x03a2uWa2ha2Ba2\0\x87`\x01aA\xBDV[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[c\xFF\xFF\xFF\xFF\x16\x90Pa3\x01V[\x81`\xFF\x16`\x08\x03a3\x01Wa2\xF4a2\x91a2\0\x87`\x01aA\xBDV[`\xC0\x1Cd\xFF\0\0\0\xFF`\x08\x82\x81\x1C\x91\x82\x16e\xFF\0\0\0\xFF\0\x93\x90\x91\x1B\x92\x83\x16\x17`\x10\x90\x81\x1Bg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16f\xFF\0\xFF\0\xFF\0\xFF\x92\x90\x92\x16g\xFF\0\xFF\0\xFF\0\xFF\0\x90\x93\x16\x92\x90\x92\x17\x90\x91\x1Ce\xFF\xFF\0\0\xFF\xFF\x16\x17` \x81\x81\x1C\x91\x90\x1B\x17\x90V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P[`\xFF\x90\x91\x16\x92P\x90P[\x92P\x92\x90PV[_a\n\xD0\x83\x83\x01` \x01Q\x90V[``\x83\x15a3/WP\x81a\n\xD0V[\x82Q\x15a3?W\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x1Ei\x91\x90aD\xB1V[_\x80a3f\x83`%aA\xBDV[\x84Q\x10\x15a3yWP_\x19\x90P_a3\x0BV[_\x80a3\x8A\x86a+\xEB\x87`$aA\xBDV[\x90\x97\x90\x96P\x94PPPPPV[_a\n\xD0\x83\x83a4>V[_a\n\xD0a3\xB1\x83`\x04aA\xBDV[\x84\x01` \x01Q\x90V[_\x82\x82\x81Q\x81\x10a3\xCDWa3\xCDa<|V[\x01` \x01Q`\xF8\x1C`\xFF\x03a3\xE4WP`\x08a\x068V[\x82\x82\x81Q\x81\x10a3\xF6Wa3\xF6a<|V[\x01` \x01Q`\xF8\x1C`\xFE\x03a4\rWP`\x04a\x068V[\x82\x82\x81Q\x81\x10a4\x1FWa4\x1Fa<|V[\x01` \x01Q`\xF8\x1C`\xFD\x03a46WP`\x02a\x068V[P_\x92\x91PPV[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[`@Q\x80`\xA0\x01`@R\x80_\x81R` \x01a4\x8C`@Q\x80` \x01`@R\x80``\x81RP\x90V[\x81R_` \x82\x01\x81\x90R`@\x82\x01\x81\x90R``\x90\x91\x01R\x90V[P\x80Ta4\xB2\x90a<1V[_\x82U\x80`\x1F\x10a4\xC1WPPV[`\x1F\x01` \x90\x04\x90_R` _ \x90\x81\x01\x90a4\xDD\x91\x90a57V[PV[`@Q\x80a\x01\0\x01`@R\x80_\x81R` \x01a5\x08`@Q\x80` \x01`@R\x80``\x81RP\x90V[\x81R_` \x82\x01\x81\x90R`@\x82\x01\x81\x90R``\x82\x01\x81\x90R`\x80\x82\x01\x81\x90R`\xA0\x82\x01\x81\x90R`\xC0\x90\x91\x01R\x90V[[\x80\x82\x11\x15a5KW_\x81U`\x01\x01a58V[P\x90V[__`@\x83\x85\x03\x12\x15a5`W__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_\x81Q` \x84Ra\x1DZ` \x85\x01\x82a5oV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a5\xE1W\x81Q\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a5\xC3V[P\x93\x94\x93PPPPV[_`@\x82\x01`@\x83R\x80\x85Q\x80\x83R``\x85\x01\x91P``\x81`\x05\x1B\x86\x01\x01\x92P` \x87\x01_[\x82\x81\x10\x15a6\xADW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x87\x86\x03\x01\x84R\x81Q\x80Q\x86R` \x81\x01Q`\xA0` \x88\x01Ra6_`\xA0\x88\x01\x82a5\x9DV[\x90P`\x01`\x01`\xA0\x1B\x03`@\x83\x01Q\x16`@\x88\x01R``\x82\x01Q``\x88\x01R`\x01`\x01`\xA0\x1B\x03`\x80\x83\x01Q\x16`\x80\x88\x01R\x80\x96PPP` \x82\x01\x91P` \x84\x01\x93P`\x01\x81\x01\x90Pa6\x11V[PPPP\x82\x81\x03` \x84\x01Ra)J\x81\x85a5\xB1V[_` \x82\x84\x03\x12\x15a6\xD3W__\xFD[P\x91\x90PV[___``\x84\x86\x03\x12\x15a6\xEBW__\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a7\x08W__\xFD[a7\x14\x86\x82\x87\x01a6\xC3V[\x93\x96\x93\x95PPPP`@\x91\x90\x91\x015\x90V[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a7\x1CWa>\x1Ca<\x04V[a>0\x81a>*\x84Ta<1V[\x84a=\xBEV[` `\x1F\x82\x11`\x01\x81\x14a>bW_\x83\x15a>KWP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x1ErV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a>\x91W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a>qV[P\x84\x82\x10\x15a>\xAEW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[\x81\x83R\x81\x81` \x85\x017P_` \x82\x84\x01\x01R_` `\x1F\x19`\x1F\x84\x01\x16\x84\x01\x01\x90P\x92\x91PPV[_\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\xFF\xE1\x836\x03\x01\x81\x12a?\x18W__\xFD[\x82\x01` \x81\x01\x905g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a?4W__\xFD[\x806\x03\x82\x13\x15a?BW__\xFD[` \x85Ra)J` \x86\x01\x82\x84a>\xBDV[`\x80\x81R_a?f`\x80\x83\x01\x87a>\xE6V[` \x83\x01\x95\x90\x95RP`@\x81\x01\x92\x90\x92R`\x01`\x01`\xA0\x1B\x03\x16``\x90\x91\x01R\x91\x90PV[\x84\x81R`\x80` \x82\x01R_a?\xA3`\x80\x83\x01\x86a>\xE6V[`\x01`\x01`\xA0\x1B\x03\x94\x90\x94\x16`@\x83\x01RP``\x01R\x92\x91PPV[__\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?\xF2W__\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a@\x0CW__\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a3\x0BW__\xFD[` \x81R_a\x1DZ` \x83\x01\x84\x86a>\xBDV[\x805\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\x14a7W__\xFD[aAJ6\x82\x86\x01a<\xD2V[\x82RP` \x83\x81\x015\x90\x82\x01R`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aApW__\xFD[aA|6\x82\x86\x01a<\xD2V[`@\x83\x01RP``\x83\x81\x015\x90\x82\x01R`\x80\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aA\xA5W__\xFD[aA\xB16\x82\x86\x01a<\xD2V[`\x80\x83\x01RP\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x068Wa\x068a;(V[\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\x83`\xF8\x1B\x16\x81R__\x83TaB\x05\x81a<1V[`\x01\x82\x16\x80\x15aB\x1CW`\x01\x81\x14aBUWaB\x8BV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x83\x16`\x01\x87\x01R`\x01\x82\x15\x15\x83\x02\x87\x01\x01\x93PaB\x8BV[\x86_R` _ _[\x83\x81\x10\x15aB\x80W\x81T`\x01\x82\x8A\x01\x01R`\x01\x82\x01\x91P` \x81\x01\x90PaB^V[PP`\x01\x82\x87\x01\x01\x93P[P\x91\x96\x95PPPPPPV[_` \x82\x84\x03\x12\x15aB\xA7W__\xFD[\x81Q\x80\x15\x15\x81\x14a\n\xD0W__\xFD[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[\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\x85\x16\x81R_aC\taC\x03`\x04\x84\x01\x87aB\xB6V[\x85aB\xB6V[\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\x93\x90\x93\x16\x83RPP`\x04\x01\x93\x92PPPV[_a\n\xD0\x82\x84aB\xB6V[_` \x82\x84\x03\x12\x15aCWW__\xFD[PQ\x91\x90PV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x068Wa\x068a;(V[_\x82aC\x8CWaC\x8Ca;lV[P\x06\x90V[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x068Wa\x068a;(V[`\x01\x81[`\x01\x84\x11\x15aC\xE5W\x80\x85\x04\x81\x11\x15aC\xC9WaC\xC9a;(V[`\x01\x84\x16\x15aC\xD7W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02aC\xAEV[\x93P\x93\x91PPV[_\x82aC\xFBWP`\x01a\x068V[\x81aD\x07WP_a\x068V[\x81`\x01\x81\x14aD\x1DW`\x02\x81\x14aD'WaDCV[`\x01\x91PPa\x068V[`\xFF\x84\x11\x15aD8WaD8a;(V[PP`\x01\x82\x1Ba\x068V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15aDfWP\x81\x81\na\x068V[aDr_\x19\x84\x84aC\xAAV[\x80_\x19\x04\x82\x11\x15aD\x85WaD\x85a;(V[\x02\x93\x92PPPV[_a\n\xD0\x83\x83aC\xEDV[`\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x068Wa\x068a;(V[` \x81R_a\n\xD0` \x83\x01\x84a5oV\xFE\xA2dipfsX\"\x12 A\xDF\x18\xE5x\xA0A\xC2\xE5-\x8F\x05\xEBc;\xA9l\0\x11;`\x87?x\xCB\xE1J\xFF\x1C\xB1\x7F\x07dsolcC\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\x01nW_5`\xE0\x1C\x80cj\x8C\xDE:\x11a\0\xD2W\x80c\xC5jE&\x11a\0\x88W\x80c\xDFi\xB1O\x11a\0cW\x80c\xDFi\xB1O\x14a\x03\xB2W\x80c\xEC\xCA,6\x14a\x03\xC5W\x80c\xFD?\xC2E\x14a\x042W__\xFD[\x80c\xC5jE&\x14a\x03|W\x80c\xCE\x1B\x81_\x14a\x03\x8FW\x80c\xD1\x92\x0F\xF0\x14a\x03\xA9W__\xFD[\x80c\xA3\x83\x01;\x11a\0\xB8W\x80c\xA3\x83\x01;\x14a\x02\xBAW\x80c\xB2#\xD9v\x14a\x02\xCDW\x80c\xBD*~>\x14a\x02\xE0W__\xFD[\x80cj\x8C\xDE:\x14a\x02\x8EW\x80c\x9C\xC6r.\x14a\x02\xA4W__\xFD[\x80cAEd\n\x11a\x01'W\x80cW+l\x05\x11a\x01\rW\x80cW+l\x05\x14a\x024W\x80c[\x8F\xE0B\x14a\x02eW\x80ch\x11\xA3\x11\x14a\x02xW__\xFD[\x80cAEd\n\x14a\x01\xFAW\x80cPj\x10\x9D\x14a\x02!W__\xFD[\x80c!\x0E\xC1\x81\x11a\x01WW\x80c!\x0E\xC1\x81\x14a\x01\xAEW\x80c6O\x1E\xC0\x14a\x01\xC1W\x80c:\xF3\xFC~\x14a\x01\xD6W__\xFD[\x80c\x11\xC17\xAA\x14a\x01rW\x80c\x1D\xFEu\x95\x14a\x01\x98W[__\xFD[a\x01\x85a\x01\x806`\x04a5OV[a\x04EV[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\x01\xA0a\x06>V[`@Qa\x01\x8F\x92\x91\x90a5\xEBV[a\x01\x85a\x01\xBC6`\x04a6\xD9V[a\x08\xA0V[a\x01\xD4a\x01\xCF6`\x04a7AV[a\n\xD7V[\0[a\x01\xE9a\x01\xE46`\x04a7\x9CV[a\x0C,V[`@Qa\x01\x8F\x95\x94\x93\x92\x91\x90a7\xB3V[a\x02\ra\x02\x086`\x04a7\x9CV[a\x0C\xFEV[`@Qa\x01\x8F\x98\x97\x96\x95\x94\x93\x92\x91\x90a7\xFBV[a\x01\xD4a\x02/6`\x04a7\x9CV[a\r\xEFV[a\x02Ua\x02B6`\x04a8PV[_T`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x91\x16\x14\x90V[`@Q\x90\x15\x15\x81R` \x01a\x01\x8FV[a\x01\xD4a\x02s6`\x04a8iV[a\x0E\xD4V[a\x02\x80a\x0F\xF0V[`@Qa\x01\x8F\x92\x91\x90a8\x9CV[a\x02\x96a\x11\xB4V[`@Qa\x01\x8F\x92\x91\x90a9+V[a\x02\xACa\x13\xBAV[`@Qa\x01\x8F\x92\x91\x90a9\xC3V[a\x01\xD4a\x02\xC86`\x04a7\x9CV[a\x16\x1DV[a\x01\xD4a\x02\xDB6`\x04a:\xB1V[a\x16\xC1V[a\x039a\x02\xEE6`\x04a7\x9CV[`\x02` \x81\x90R_\x91\x82R`@\x90\x91 \x80T`\x01\x82\x01T\x92\x82\x01T`\x03\x83\x01T`\x04\x84\x01T`\x05\x85\x01T`\x06\x90\x95\x01T\x93\x95\x94`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x94\x92\x93\x91\x82\x16\x92\x91\x16\x90\x87V[`@\x80Q\x97\x88R` \x88\x01\x96\x90\x96R`\x01`\x01`\xA0\x1B\x03\x94\x85\x16\x95\x87\x01\x95\x90\x95R``\x86\x01\x92\x90\x92R\x82\x16`\x80\x85\x01R\x16`\xA0\x83\x01R`\xC0\x82\x01R`\xE0\x01a\x01\x8FV[a\x01\xD4a\x03\x8A6`\x04a7\x9CV[a\x18]V[_T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01\x8FV[a\x01\x85aT`\x81V[a\x01\xD4a\x03\xC06`\x04a7\x9CV[a\x19@V[a\x04\x07a\x03\xD36`\x04a7\x9CV[`\x03` \x81\x90R_\x91\x82R`@\x90\x91 \x80T`\x01\x82\x01T`\x02\x83\x01T\x92\x90\x93\x01T\x90\x92`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x92\x91\x16\x84V[`@\x80Q\x94\x85R`\x01`\x01`\xA0\x1B\x03\x93\x84\x16` \x86\x01R\x84\x01\x91\x90\x91R\x16``\x82\x01R`\x80\x01a\x01\x8FV[a\x01\xD4a\x04@6`\x04a:\xB1V[a\x1ASV[_\x82\x81R`\x01` R`@\x81 \x80T\x83\x11\x15a\x04_W__\xFD[_\x83\x11a\x04jW__\xFD[\x80T`\x03\x82\x01T_\x91\x90a\x04~\x90\x86a;UV[a\x04\x88\x91\x90a;\x99V[\x90P_\x81\x11a\x04\x99Wa\x04\x99a;\xACV[\x80\x82`\x03\x01T\x10\x15a\x04\xADWa\x04\xADa;\xACV[\x80\x82`\x03\x01_\x82\x82Ta\x04\xC0\x91\x90a;\xD9V[\x90\x91UPP\x81T\x84\x90\x83\x90_\x90a\x04\xD8\x90\x84\x90a;\xD9V[\x90\x91UPP`@\x80Q`\xE0\x81\x01\x82R\x86\x81R` \x81\x01\x86\x90R`\x02\x84\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x92\x82\x01\x92\x90\x92R``\x81\x01\x83\x90R`\x04\x84\x01T\x90\x91\x16`\x80\x82\x01R_\x90`\xA0\x81\x01a\x05*a\x1B\xE0V[`\x01`\x01`\xA0\x1B\x03\x16\x81RB` \x90\x91\x01R`\x05\x80T\x91\x92P_\x91\x90\x82a\x05P\x83a;\xECV[\x90\x91UP_\x81\x81R`\x02` \x81\x81R`@\x92\x83\x90 \x86Q\x81U\x86\x82\x01Q`\x01\x82\x01U\x86\x84\x01Q\x81\x84\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x17\x90\x91U``\x80\x8A\x01Q`\x03\x85\x01U`\x80\x8A\x01Q`\x04\x85\x01\x80T\x84\x16\x91\x85\x16\x91\x90\x91\x17\x90U`\xA0\x8A\x01Q`\x05\x85\x01\x80T\x90\x93\x16\x90\x84\x16\x17\x90\x91U`\xC0\x89\x01Q`\x06\x90\x93\x01\x92\x90\x92U\x92\x89\x01T\x84Q\x8C\x81R\x92\x83\x01\x89\x90R\x90\x92\x16\x92\x81\x01\x92\x90\x92R\x91\x92P\x82\x91\x89\x91\x7F\xC3\x9A\x1A]\xDC\x0E\x85\xC9U\xFE.\x1A\xBE\xB4<\x94\xCE\x182.u\xBB=D\xE8\x0Fu\x9F\xF9\xD04\xB9\x91\x01`@Q\x80\x91\x03\x90\xA3\x93PPPP[\x92\x91PPV[``\x80_\x80[`\x05T\x81\x10\x15a\x06\x83W_\x81\x81R`\x01` R`@\x90 `\x04\x01T`\x01`\x01`\xA0\x1B\x03\x16\x15a\x06{W\x81a\x06w\x81a;\xECV[\x92PP[`\x01\x01a\x06DV[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\x9EWa\x06\x9Ea<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x06\xD7W\x81` \x01[a\x06\xC4a4eV[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x06\xBCW\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\xF4Wa\x06\xF4a<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x07\x1DW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x05T\x81\x10\x15a\x08\x94W_\x81\x81R`\x01` R`@\x90 `\x04\x01T`\x01`\x01`\xA0\x1B\x03\x16\x15a\x08\x8CW`\x01_\x82\x81R` \x01\x90\x81R` \x01_ `@Q\x80`\xA0\x01`@R\x90\x81_\x82\x01T\x81R` \x01`\x01\x82\x01`@Q\x80` \x01`@R\x90\x81_\x82\x01\x80Ta\x07\x90\x90a<1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07\xBC\x90a<1V[\x80\x15a\x08\x07W\x80`\x1F\x10a\x07\xDEWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x08\x07V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\xEAW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP\x81R`\x02\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16` \x83\x01R`\x03\x83\x01T`@\x83\x01R`\x04\x90\x92\x01T\x90\x91\x16``\x90\x91\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x08UWa\x08Ua<|V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x08sWa\x08sa<|V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x08\x88\x81a;\xECV[\x92PP[`\x01\x01a\x07#V[P\x91\x95\x90\x94P\x92PPPV[_\x83\x81R`\x03` R`@\x81 \x82a\x08\xB6W__\xFD[\x80T\x83\x11\x15a\x08\xC3W__\xFD[\x80T`\x02\x82\x01T_\x91\x90a\x08\xD7\x90\x86a;UV[a\x08\xE1\x91\x90a;\x99V[\x90P_\x81\x11a\x08\xF2Wa\x08\xF2a;\xACV[\x80\x82`\x02\x01T\x10\x15a\t\x06Wa\t\x06a;\xACV[\x80\x82`\x02\x01_\x82\x82Ta\t\x19\x91\x90a;\xD9V[\x90\x91UPP\x81T\x84\x90\x83\x90_\x90a\t1\x90\x84\x90a;\xD9V[\x90\x91UPa\tX\x90Pa\tBa\x1B\xE0V[`\x01\x84\x01T`\x01`\x01`\xA0\x1B\x03\x16\x900\x84a\x1C0V[`\x05\x80T_\x91\x82a\th\x83a;\xECV[\x91\x90PU\x90P`@Q\x80a\x01\0\x01`@R\x80\x88\x81R` \x01\x87a\t\x8A\x90a=]V[\x81R` \x81\x01\x87\x90R`\x01\x85\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`@\x83\x01R``\x82\x01\x85\x90R`\x03\x86\x01T\x16`\x80\x82\x01R`\xA0\x01a\t\xC5a\x1B\xE0V[`\x01`\x01`\xA0\x1B\x03\x16\x81RB` \x91\x82\x01R_\x83\x81R`\x04\x82R`@\x90 \x82Q\x81U\x90\x82\x01Q\x80Q`\x01\x83\x01\x90\x81\x90a\t\xFE\x90\x82a>\x02V[PPP`@\x82\x81\x01Q`\x02\x83\x01U``\x83\x01Q`\x03\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x17\x90\x91U`\x80\x85\x01Q`\x04\x85\x01U`\xA0\x85\x01Q`\x05\x85\x01\x80T\x83\x16\x91\x84\x16\x91\x90\x91\x17\x90U`\xC0\x85\x01Q`\x06\x85\x01\x80T\x90\x92\x16\x90\x83\x16\x17\x90U`\xE0\x90\x93\x01Q`\x07\x90\x92\x01\x91\x90\x91U`\x01\x85\x01T\x90Q\x83\x92\x8A\x92\x7Fe>\r\x81\xF2\xC9\x9B\xEB\xA3Y\xDF\xB1{I\x9A\\\xFF+\xE9\xD9PQHR\"M\xF8\xC0\x97\xC2\x19!\x92a\n\xC3\x92\x8C\x92\x8C\x92\x8A\x92\x91\x90\x91\x16\x90a?TV[`@Q\x80\x91\x03\x90\xA3\x92PPP[\x93\x92PPPV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\n\xE9W__\xFD[a\x0B\x06a\n\xF4a\x1B\xE0V[`\x01`\x01`\xA0\x1B\x03\x84\x16\x900\x84a\x1C0V[`\x05\x80T_\x91\x82a\x0B\x16\x83a;\xECV[\x91\x90PU\x90P`@Q\x80`\xA0\x01`@R\x80\x86\x81R` \x01\x85a\x0B7\x90a=]V[\x81R` \x01\x84`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x83\x81R` \x01a\x0BYa\x1B\xE0V[`\x01`\x01`\xA0\x1B\x03\x16\x90R_\x82\x81R`\x01` \x81\x81R`@\x90\x92 \x83Q\x81U\x91\x83\x01Q\x80Q\x90\x91\x83\x01\x90\x81\x90a\x0B\x8F\x90\x82a>\x02V[PPP`@\x82\x81\x01Q`\x02\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x17\x90\x91U``\x85\x01Q`\x03\x85\x01U`\x80\x90\x94\x01Q`\x04\x90\x93\x01\x80T\x90\x94\x16\x92\x16\x91\x90\x91\x17\x90\x91UQ\x7F\x98\xC7\xC6\x80@=G@=\xEAJW\r\x0ElW\x16S\x8CIB\x0E\xF4q\xCE\xC4(\xF5\xA5\x85,\x06\x90a\x0C\x1D\x90\x87\x90\x87\x90\x87\x90\x87\x90a?\x8BV[`@Q\x80\x91\x03\x90\xA1PPPPPV[`\x01` \x81\x81R_\x92\x83R`@\x92\x83\x90 \x80T\x84Q\x92\x83\x01\x90\x94R\x91\x82\x01\x80T\x82\x90\x82\x90a\x0CY\x90a<1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C\x85\x90a<1V[\x80\x15a\x0C\xD0W\x80`\x1F\x10a\x0C\xA7Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C\xD0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0C\xB3W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP`\x02\x82\x01T`\x03\x83\x01T`\x04\x90\x93\x01T\x91\x92`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x92\x90\x91\x16\x85V[`\x04` R\x80_R`@_ _\x91P\x90P\x80_\x01T\x90\x80`\x01\x01`@Q\x80` \x01`@R\x90\x81_\x82\x01\x80Ta\r2\x90a<1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r^\x90a<1V[\x80\x15a\r\xA9W\x80`\x1F\x10a\r\x80Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\r\xA9V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r\x8CW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP`\x02\x82\x01T`\x03\x83\x01T`\x04\x84\x01T`\x05\x85\x01T`\x06\x86\x01T`\x07\x90\x96\x01T\x94\x95\x93\x94`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x94\x92\x93\x91\x82\x16\x92\x90\x91\x16\x90\x88V[_\x81\x81R`\x01` R`@\x90 a\x0E\x04a\x1B\xE0V[`\x04\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x0E\x1FW__\xFD[a\x0EDa\x0E*a\x1B\xE0V[`\x03\x83\x01T`\x02\x84\x01T`\x01`\x01`\xA0\x1B\x03\x16\x91\x90a\x1C\xE7V[_\x82\x81R`\x01` \x81\x90R`@\x82 \x82\x81U\x91\x90\x82\x01\x81a\x0Ee\x82\x82a4\xA6V[PPP`\x02\x81\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U_`\x03\x83\x01U`\x04\x90\x91\x01\x80T\x90\x91\x16\x90U`@Q\x82\x81R\x7F\xC3@\xE7\xACH\xDC\x80\xEEy?\xC6&i`\xBD_\x1B\xD2\x1B\xE9\x1C\x8A\x95\xE2\x18\x17\x81\x13\xF7\x9E\x17\xB4\x90` \x01[`@Q\x80\x91\x03\x90\xA1PPV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x0E\xE6W__\xFD[_\x83\x11a\x0E\xF1W__\xFD[_\x81\x11a\x0E\xFCW__\xFD[`\x05\x80T_\x91\x82a\x0F\x0C\x83a;\xECV[\x91\x90PU\x90P`@Q\x80`\x80\x01`@R\x80\x85\x81R` \x01\x84`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x83\x81R` \x01a\x0F@a\x1B\xE0V[`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x90\x91R_\x83\x81R`\x03` \x81\x81R`@\x92\x83\x90 \x85Q\x81U\x85\x82\x01Q`\x01\x82\x01\x80T\x91\x87\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x92\x83\x16\x17\x90U\x86\x85\x01Q`\x02\x83\x01U``\x96\x87\x01Q\x91\x90\x93\x01\x80T\x91\x86\x16\x91\x90\x93\x16\x17\x90\x91U\x81Q\x88\x81R\x92\x87\x16\x90\x83\x01R\x81\x01\x84\x90R\x82\x91\x7F\xFF\x1C\xE2\x10\xDE\xFC\xD3\xBA\x1A\xDFv\xC9A\x9A\x07X\xFA`\xFD>\xB3\x8C{\xD9A\x8F`\xB5u\xB7n$\x91\x01`@Q\x80\x91\x03\x90\xA2PPPPV[``\x80_\x80[`\x05T\x81\x10\x15a\x106W_\x81\x81R`\x03` \x81\x90R`@\x90\x91 \x01T`\x01`\x01`\xA0\x1B\x03\x16\x15a\x10.W\x81a\x10*\x81a;\xECV[\x92PP[`\x01\x01a\x0F\xF6V[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10QWa\x10Qa<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x10\xA1W\x81` \x01[`@\x80Q`\x80\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x92\x82\x01\x81\x90R``\x82\x01R\x82R_\x19\x90\x92\x01\x91\x01\x81a\x10oW\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10\xBEWa\x10\xBEa<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x10\xE7W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x05T\x81\x10\x15a\x08\x94W_\x81\x81R`\x03` \x81\x90R`@\x90\x91 \x01T`\x01`\x01`\xA0\x1B\x03\x16\x15a\x11\xACW_\x81\x81R`\x03` \x81\x81R`@\x92\x83\x90 \x83Q`\x80\x81\x01\x85R\x81T\x81R`\x01\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x93\x82\x01\x93\x90\x93R`\x02\x82\x01T\x94\x81\x01\x94\x90\x94R\x90\x91\x01T\x16``\x82\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x11uWa\x11ua<|V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x11\x93Wa\x11\x93a<|V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x11\xA8\x81a;\xECV[\x92PP[`\x01\x01a\x10\xEDV[``\x80_\x80[`\x05T\x81\x10\x15a\x11\xF0W_\x81\x81R`\x02` R`@\x90 `\x01\x01T\x15a\x11\xE8W\x81a\x11\xE4\x81a;\xECV[\x92PP[`\x01\x01a\x11\xBAV[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\x0BWa\x12\x0Ba<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x12\x90W\x81` \x01[a\x12}`@Q\x80`\xE0\x01`@R\x80_\x81R` \x01_\x81R` \x01_`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01_\x81R` \x01_`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01_`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01_\x81RP\x90V[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x12)W\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\xADWa\x12\xADa<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x12\xD6W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x05T\x81\x10\x15a\x08\x94W_\x81\x81R`\x02` R`@\x90 `\x01\x01T\x15a\x13\xB2W_\x81\x81R`\x02` \x81\x81R`@\x92\x83\x90 \x83Q`\xE0\x81\x01\x85R\x81T\x81R`\x01\x82\x01T\x92\x81\x01\x92\x90\x92R\x91\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x93\x82\x01\x93\x90\x93R`\x03\x82\x01T``\x82\x01R`\x04\x82\x01T\x83\x16`\x80\x82\x01R`\x05\x82\x01T\x90\x92\x16`\xA0\x83\x01R`\x06\x01T`\xC0\x82\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x13{Wa\x13{a<|V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x13\x99Wa\x13\x99a<|V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x13\xAE\x81a;\xECV[\x92PP[`\x01\x01a\x12\xDCV[``\x80_\x80[`\x05T\x81\x10\x15a\x13\xF6W_\x81\x81R`\x04` R`@\x90 `\x02\x01T\x15a\x13\xEEW\x81a\x13\xEA\x81a;\xECV[\x92PP[`\x01\x01a\x13\xC0V[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x14\x11Wa\x14\x11a<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x14JW\x81` \x01[a\x147a4\xE0V[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x14/W\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x14gWa\x14ga<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x14\x90W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x05T\x81\x10\x15a\x08\x94W_\x81\x81R`\x04` R`@\x90 `\x02\x01T\x15a\x16\x15W`\x04_\x82\x81R` \x01\x90\x81R` \x01_ `@Q\x80a\x01\0\x01`@R\x90\x81_\x82\x01T\x81R` \x01`\x01\x82\x01`@Q\x80` \x01`@R\x90\x81_\x82\x01\x80Ta\x14\xFB\x90a<1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x15'\x90a<1V[\x80\x15a\x15rW\x80`\x1F\x10a\x15IWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x15rV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15UW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP\x81R`\x02\x82\x01T` \x82\x01R`\x03\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`@\x83\x01R`\x04\x83\x01T``\x83\x01R`\x05\x83\x01T\x81\x16`\x80\x83\x01R`\x06\x83\x01T\x16`\xA0\x82\x01R`\x07\x90\x91\x01T`\xC0\x90\x91\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x15\xDEWa\x15\xDEa<|V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x15\xFCWa\x15\xFCa<|V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x16\x11\x81a;\xECV[\x92PP[`\x01\x01a\x14\x96V[_\x81\x81R`\x03` R`@\x90 a\x162a\x1B\xE0V[`\x03\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x16MW__\xFD[_\x82\x81R`\x03` \x81\x81R`@\x80\x84 \x84\x81U`\x01\x81\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U`\x02\x82\x01\x95\x90\x95U\x90\x92\x01\x80T\x90\x93\x16\x90\x92UQ\x83\x81R\x7F<\xD4u\xB0\x92\xE8\xB3y\xF6\xBA\r\x9E\x0E\x0C\x8F0p^s2\x1D\xC5\xC9\xF8\x0C\xE4\xAD8\xDB{\xE1\xAA\x91\x01a\x0E\xC8V[_\x83\x81R`\x02` R`@\x90 a\x16\xD6a\x1B\xE0V[`\x05\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x16\xF1W__\xFD[`\x06T`\x01`\x01`\xA0\x1B\x03\x16c\xD3\x8C)\xA1a\x17\x0F`@\x85\x01\x85a?\xBFV[`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x17,\x92\x91\x90a@ V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x17CW__\xFD[PZ\xF1\x15\x80\x15a\x17UW=__>=_\xFD[PPPPa\x17\x86`\x07T\x84a\x17i\x90a@bV[a\x17r\x85aA\x10V[`\x06T`\x01`\x01`\xA0\x1B\x03\x16\x92\x91\x90a\x1D5V[P\x80T_\x90\x81R`\x01` \x81\x90R`@\x90\x91 \x80T\x90\x91a\x17\xAA\x91\x90\x83\x01\x86a\x1DbV[`\x05\x82\x01T`\x03\x83\x01T`\x02\x84\x01Ta\x17\xD1\x92`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x92\x91\x16\x90a\x1C\xE7V[_\x85\x81R`\x02` \x81\x81R`@\x80\x84 \x84\x81U`\x01\x81\x01\x85\x90U\x92\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U`\x03\x84\x01\x85\x90U`\x04\x84\x01\x80T\x82\x16\x90U`\x05\x84\x01\x80T\x90\x91\x16\x90U`\x06\x90\x92\x01\x92\x90\x92UQ\x86\x81R\x7F\xB4\xC9\x8D\xE2\x10ik<\xF2\x1E\x993\\\x1E\xE3\xA0\xAE4\xA2g\x13A*J\xDD\xE8\xAFYav\xF3~\x91\x01a\x0C\x1DV[_\x81\x81R`\x02` R`@\x90 a\x18ra\x1B\xE0V[`\x04\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x18\x8DW__\xFD[aT`\x81`\x06\x01Ta\x18\x9F\x91\x90aA\xBDV[B\x11a\x18\xA9W__\xFD[a\x18\xB4a\x0E*a\x1B\xE0V[_\x82\x81R`\x02` \x81\x81R`@\x80\x84 \x84\x81U`\x01\x81\x01\x85\x90U\x92\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U`\x03\x84\x01\x85\x90U`\x04\x84\x01\x80T\x82\x16\x90U`\x05\x84\x01\x80T\x90\x91\x16\x90U`\x06\x90\x92\x01\x92\x90\x92UQ\x83\x81R\x7F>^\xA3X\xE9\xEBL\xDFD\xCD\xC7y8\xAD\xE8\x07K\x12@\xA6\xD8\xC0\xFD\x13r\x86q\xB8.\x80\n\xD6\x91\x01a\x0E\xC8V[_\x81\x81R`\x04` R`@\x90 `\x07\x81\x01Ta\x19_\x90aT`\x90aA\xBDV[B\x11a\x19iW__\xFD[a\x19qa\x1B\xE0V[`\x06\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x19\x8CW__\xFD[a\x19\xB1a\x19\x97a\x1B\xE0V[`\x04\x83\x01T`\x03\x84\x01T`\x01`\x01`\xA0\x1B\x03\x16\x91\x90a\x1C\xE7V[_\x82\x81R`\x04` R`@\x81 \x81\x81U\x90`\x01\x82\x01\x81a\x19\xD1\x82\x82a4\xA6V[PP_`\x02\x83\x01\x81\x90U`\x03\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U`\x04\x84\x01\x82\x90U`\x05\x84\x01\x80T\x82\x16\x90U`\x06\x84\x01\x80T\x90\x91\x16\x90U`\x07\x90\x92\x01\x91\x90\x91UP`@Q\x82\x81R\x7Fx\xF5\x1Fb\xF7\xCF\x13\x81\xC6s\xC2~\xAE\x18}\xD6\xC5\x88\xDCf$\xCEYi}\xBB>\x1D|\x1B\xBC\xDF\x90` \x01a\x0E\xC8V[_\x83\x81R`\x04` R`@\x90 a\x1Aha\x1B\xE0V[`\x05\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x1A\x83W__\xFD[`\x06T`\x01`\x01`\xA0\x1B\x03\x16c\xD3\x8C)\xA1a\x1A\xA1`@\x85\x01\x85a?\xBFV[`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1A\xBE\x92\x91\x90a@ V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1A\xD5W__\xFD[PZ\xF1\x15\x80\x15a\x1A\xE7W=__>=_\xFD[PPPPa\x1A\xFB`\x07T\x84a\x17i\x90a@bV[Pa\x1B\x0E\x81`\x02\x01T\x82`\x01\x01\x85a\x1DbV[`\x05\x81\x01T`\x04\x82\x01T`\x03\x83\x01Ta\x1B5\x92`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x92\x91\x16\x90a\x1C\xE7V[_\x84\x81R`\x04` R`@\x81 \x81\x81U\x90`\x01\x82\x01\x81a\x1BU\x82\x82a4\xA6V[PP_`\x02\x83\x01\x81\x90U`\x03\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U`\x04\x84\x01\x82\x90U`\x05\x84\x01\x80T\x82\x16\x90U`\x06\x84\x01\x80T\x90\x91\x16\x90U`\x07\x90\x92\x01\x91\x90\x91UP`@Q\x84\x81R\x7F\xCFV\x10a\xDBx\xF7\xBCQ\x8D7\xFE\x86q\x85\x14\xC6@\xCC\xC5\xC3\xF1)8(\xB9U\xE6\x8F\x19\xF5\xFB\x90` \x01`@Q\x80\x91\x03\x90\xA1PPPPV[_`\x146\x10\x80\x15\x90a\x1B\xFBWP_T`\x01`\x01`\xA0\x1B\x03\x163\x14[\x15a\x1C+WP\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xEC6\x015``\x1C\x90V[P3\x90V[`@Q`\x01`\x01`\xA0\x1B\x03\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x1C\xE1\x90\x85\x90\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\x90`\x84\x01[`@\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\x1EyV[PPPPV[`@Q`\x01`\x01`\xA0\x1B\x03\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x1D0\x90\x84\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\x90`d\x01a\x1C}V[PPPV[_a\x1D?\x83a\x1F]V[\x90Pa\x1DK\x81\x83a MV[a\x1DZ\x85\x85\x84`@\x01Qa\"\xB1V[\x94\x93PPPPV[_\x82_\x01\x80Ta\x1Dq\x90a<1V[`@Qa\x1D\x83\x92P\x85\x90` \x01aA\xD0V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P_a\x1D\xEA\x83\x80`@\x01\x90a\x1D\xAF\x91\x90a?\xBFV[\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\x91RP\x86\x92Pa&\x01\x91PPV[Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x84\x81\x10\x15a\x1ErW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`;`$\x82\x01R\x7FBitcoin transaction amount is lo`D\x82\x01R\x7Fwer than in accepted order.\0\0\0\0\0`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[PPPPPV[_a\x1E\xCD\x82`@Q\x80`@\x01`@R\x80` \x81R` \x01\x7FSafeERC20: low-level call failed\x81RP\x85`\x01`\x01`\xA0\x1B\x03\x16a'\x9F\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x1D0W\x80\x80` \x01\x90Q\x81\x01\x90a\x1E\xEB\x91\x90aB\x97V[a\x1D0W`@QbF\x1B\xCD`\xE5\x1B\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\x1EiV[_a\x1Fk\x82` \x01Qa'\xADV[a\x1F\xB7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FInvalid input vector provided\0\0\0`D\x82\x01R`d\x01a\x1EiV[a\x1F\xC4\x82`@\x01Qa(GV[a \x10W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FInvalid output vector provided\0\0`D\x82\x01R`d\x01a\x1EiV[a\x068\x82_\x01Q\x83` \x01Q\x84`@\x01Q\x85``\x01Q`@Q` \x01a 9\x94\x93\x92\x91\x90aB\xCDV[`@Q` \x81\x83\x03\x03\x81R\x90`@Ra(\xD4V[\x80Qa X\x90a(\xF6V[a \xA4W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7FBad merkle array proof\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x1EiV[`\x80\x81\x01QQ\x81QQ\x14a! W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`/`$\x82\x01R\x7FTx not on same level of merkle t`D\x82\x01R\x7Free as coinbase\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x1EiV[_a!.\x82`@\x01Qa)\x0CV[\x82Q` \x84\x01Q\x91\x92Pa!E\x91\x85\x91\x84\x91a)\x18V[a!\xB7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`<`$\x82\x01R\x7FTx merkle proof is not valid for`D\x82\x01R\x7F provided header and tx hash\0\0\0\0`d\x82\x01R`\x84\x01a\x1EiV[_`\x02\x83``\x01Q`@Q` \x01a!\xD1\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra!\xEB\x91aC=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\")\x91\x90aCGV[`\x80\x84\x01Q\x90\x91Pa\"?\x90\x82\x90\x84\x90_a)\x18V[a\x1C\xE1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`?`$\x82\x01R\x7FCoinbase merkle proof is not val`D\x82\x01R\x7Fid for provided header and hash\0`d\x82\x01R`\x84\x01a\x1EiV[_\x83`\x01`\x01`\xA0\x1B\x03\x16c\x117d\xBE`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\"\xEEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a#\x12\x91\x90aCGV[\x90P_\x84`\x01`\x01`\xA0\x1B\x03\x16c+\x97\xBE$`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a#QW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a#u\x91\x90aCGV[\x90P_\x80a#\x8Aa#\x85\x86a)SV[a)^V[\x90P\x83\x81\x03a#\x9BW\x83\x91Pa$\x18V[\x82\x81\x03a#\xAAW\x82\x91Pa$\x18V[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`%`$\x82\x01R\x7FNot at current or previous diffi`D\x82\x01R\x7Fculty\0\0\0\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\x1EiV[_a$\"\x86a)\x85V[\x90P_\x19\x81\x03a$\x9AW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`#`$\x82\x01R\x7FInvalid length of the headers ch`D\x82\x01R\x7Fain\0\0\0\0\0\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\x1EiV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81\x03a%\tW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FInvalid headers chain\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x1EiV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFD\x81\x03a%xW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FInsufficient work in a header\0\0\0`D\x82\x01R`d\x01a\x1EiV[a%\x82\x87\x84a;UV[\x81\x10\x15a%\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FInsufficient accumulated difficu`D\x82\x01R\x7Flty in header chain\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x1EiV[PPPPPPPPV[`@\x80Q``\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x82\x84\x01\x82\x90R\x83Q\x80\x85\x01\x90\x94R\x81\x84R\x83\x01R\x90a&5\x84a+\xA9V[` \x83\x01R\x80\x82R\x81a&G\x82a;\xECV[\x90RP_\x80[\x82` \x01Q\x81\x10\x15a'IW\x82Q_\x90a&h\x90\x88\x90a+\xBEV[\x84Q\x90\x91P_\x90a&z\x90\x89\x90a,\x1EV[\x90P_a&\x88`\x08\x84a;\xD9V[\x86Q\x90\x91P_\x90a&\x9A\x90`\x08aA\xBDV[\x8A\x81\x01` \x01\x83\x90 \x90\x91P\x80\x8A\x03a&\xD4W`\x01\x96P\x83\x89_\x01\x81\x81Qa&\xC2\x91\x90aC^V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RPa'$V[_a&\xE2\x8C\x8A_\x01Qa,\x94V[\x90P`\x01`\x01`\xA0\x1B\x03\x81\x16\x15a'\x03W`\x01`\x01`\xA0\x1B\x03\x81\x16` \x8B\x01R[_a'\x11\x8D\x8B_\x01Qa-tV[\x90P\x80\x15a'!W`@\x8B\x01\x81\x90R[PP[\x84\x88_\x01\x81\x81Qa'5\x91\x90aA\xBDV[\x90RPP`\x01\x90\x94\x01\x93Pa&M\x92PPPV[P\x80a'\x97W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FNo output found for scriptPubKey`D\x82\x01R`d\x01a\x1EiV[PP\x92\x91PPV[``a\x1DZ\x84\x84_\x85a.TV[___a'\xB9\x84a+\xA9V[\x90\x92P\x90P\x80\x15\x80a'\xCBWP_\x19\x82\x14[\x15a'\xD9WP_\x93\x92PPPV[_a'\xE5\x83`\x01aA\xBDV[\x90P_[\x82\x81\x10\x15a(:W\x85Q\x82\x10a(\x04WP_\x95\x94PPPPPV[_a(\x0F\x87\x84a/\x98V[\x90P_\x19\x81\x03a(%WP_\x96\x95PPPPPPV[a(/\x81\x84aA\xBDV[\x92PP`\x01\x01a'\xE9V[P\x93Q\x90\x93\x14\x93\x92PPPV[___a(S\x84a+\xA9V[\x90\x92P\x90P\x80\x15\x80a(eWP_\x19\x82\x14[\x15a(sWP_\x93\x92PPPV[_a(\x7F\x83`\x01aA\xBDV[\x90P_[\x82\x81\x10\x15a(:W\x85Q\x82\x10a(\x9EWP_\x95\x94PPPPPV[_a(\xA9\x87\x84a+\xBEV[\x90P_\x19\x81\x03a(\xBFWP_\x96\x95PPPPPPV[a(\xC9\x81\x84aA\xBDV[\x92PP`\x01\x01a(\x83V[_` _\x83Q` \x85\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x91\x90PV[_` \x82Qa)\x05\x91\x90aC~V[\x15\x92\x91PPV[`D\x81\x01Q_\x90a\x068V[_\x83\x85\x14\x80\x15a)&WP\x81\x15[\x80\x15a)1WP\x82Q\x15[\x15a)>WP`\x01a\x1DZV[a)J\x85\x84\x86\x85a/\xDEV[\x95\x94PPPPPV[_a\x068\x82_a0\x83V[_a\x068{\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\x83a1\x1CV[_`P\x82Qa)\x94\x91\x90aC~V[\x15a)\xA1WP_\x19\x91\x90PV[P_\x80\x80[\x83Q\x81\x10\x15a+\xA2W\x80\x15a)\xEDWa)\xC0\x84\x82\x84a1'V[a)\xEDWP\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x93\x92PPPV[_a)\xF8\x85\x83a0\x83V[\x90Pa*\x06\x85\x83`Pa1PV[\x92P\x80a+I\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a+yWP\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFD\x94\x93PPPPV[a+\x82\x81a)^V[a+\x8C\x90\x85aA\xBDV[\x93Pa+\x9B\x90P`P\x82aA\xBDV[\x90Pa)\xA6V[PP\x91\x90PV[__a+\xB5\x83_a1uV[\x91P\x91P\x91P\x91V[_a+\xCA\x82`\taA\xBDV[\x83Q\x10\x15a+\xDAWP_\x19a\x068V[_\x80a+\xF0\x85a+\xEB\x86`\x08aA\xBDV[a1uV[\x90\x92P\x90P`\x01\x82\x01a,\x08W_\x19\x92PPPa\x068V[\x80a,\x14\x83`\taA\xBDV[a)J\x91\x90aA\xBDV[_\x80a,*\x84\x84a3\x12V[`\xC0\x1C\x90P_a)J\x82d\xFF\0\0\0\xFF`\x08\x82\x81\x1C\x91\x82\x16e\xFF\0\0\0\xFF\0\x93\x90\x91\x1B\x92\x83\x16\x17`\x10\x90\x81\x1Bg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16f\xFF\0\xFF\0\xFF\0\xFF\x92\x90\x92\x16g\xFF\0\xFF\0\xFF\0\xFF\0\x90\x93\x16\x92\x90\x92\x17\x90\x91\x1Ce\xFF\xFF\0\0\xFF\xFF\x16\x17` \x81\x81\x1C\x91\x90\x1B\x17\x90V[_\x82a,\xA1\x83`\taA\xBDV[\x81Q\x81\x10a,\xB1Wa,\xB1a<|V[` \x91\x01\x01Q\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\x16\x7Fj\0\0\0\0\0\0\0\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-\x06WP_a\x068V[_\x83a-\x13\x84`\naA\xBDV[\x81Q\x81\x10a-#Wa-#a<|V[\x01` \x01Q\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\x81\x16\x91P`\xF8\x1C`\x14\x03a-mW_a-c\x84`\x0BaA\xBDV[\x85\x01`\x14\x01Q\x92PP[P\x92\x91PPV[_\x82a-\x81\x83`\taA\xBDV[\x81Q\x81\x10a-\x91Wa-\x91a<|V[` \x91\x01\x01Q\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\x16\x7Fj\0\0\0\0\0\0\0\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-\xE6WP_a\x068V[_\x83a-\xF3\x84`\naA\xBDV[\x81Q\x81\x10a.\x03Wa.\x03a<|V[\x01` \x90\x81\x01Q\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\x81\x16\x92P`\xF8\x1C\x90\x03a-mW_a.D\x84`\x0BaA\xBDV[\x85\x01` \x01Q\x92PPP\x92\x91PPV[``\x82G\x10\x15a.\xCCW`@QbF\x1B\xCD`\xE5\x1B\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\x1EiV[`\x01`\x01`\xA0\x1B\x03\x85\x16;a/#W`@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\x1EiV[__\x86`\x01`\x01`\xA0\x1B\x03\x16\x85\x87`@Qa/>\x91\x90aCa/}V[``\x91P[P\x91P\x91Pa/\x8D\x82\x82\x86a3 V[\x97\x96PPPPPPPV[___a/\xA5\x85\x85a3YV[\x90\x92P\x90P`\x01\x82\x01a/\xBDW_\x19\x92PPPa\x068V[\x80a/\xC9\x83`%aA\xBDV[a/\xD3\x91\x90aA\xBDV[a)J\x90`\x04aA\xBDV[_` \x84Qa/\xED\x91\x90aC~V[\x15a/\xF9WP_a\x1DZV[\x83Q_\x03a0\x08WP_a\x1DZV[\x81\x85_[\x86Q\x81\x10\x15a0vWa0 `\x02\x84aC~V[`\x01\x03a0DWa0=a07\x88\x83\x01` \x01Q\x90V[\x83a3\x97V[\x91Pa0]V[a0Z\x82a0U\x89\x84\x01` \x01Q\x90V[a3\x97V[\x91P[`\x01\x92\x90\x92\x1C\x91a0o` \x82aA\xBDV[\x90Pa0\x0CV[P\x90\x93\x14\x95\x94PPPPPV[_\x80a0\x9Aa0\x93\x84`HaA\xBDV[\x85\x90a3\x12V[`\xE8\x1C\x90P_\x84a0\xAC\x85`KaA\xBDV[\x81Q\x81\x10a0\xBCWa0\xBCa<|V[\x01` \x01Q`\xF8\x1C\x90P_a0\xEE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a1\x01`\x03\x84aC\x91V[`\xFF\x16\x90Pa1\x12\x81a\x01\0aD\x8DV[a/\x8D\x90\x83a;UV[_a\n\xD0\x82\x84a;\x99V[_\x80a13\x85\x85a3\xA2V[\x90P\x82\x81\x14a1EW_\x91PPa\n\xD0V[P`\x01\x94\x93PPPPV[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[___a1\x82\x85\x85a3\xBAV[\x90P\x80`\xFF\x16_\x03a1\xB5W_\x85\x85\x81Q\x81\x10a1\xA1Wa1\xA1a<|V[\x01` \x01Q\x90\x93P`\xF8\x1C\x91Pa3\x0B\x90PV[\x83a1\xC1\x82`\x01aD\x98V[`\xFF\x16a1\xCE\x91\x90aA\xBDV[\x85Q\x10\x15a1\xE3W_\x19_\x92P\x92PPa3\x0BV[_\x81`\xFF\x16`\x02\x03a2&Wa2\x1Ba2\x07a2\0\x87`\x01aA\xBDV[\x88\x90a3\x12V[b\xFF\xFF\0`\xE8\x82\x90\x1C\x16`\xF8\x91\x90\x91\x1C\x17\x90V[a\xFF\xFF\x16\x90Pa3\x01V[\x81`\xFF\x16`\x04\x03a2uWa2ha2Ba2\0\x87`\x01aA\xBDV[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[c\xFF\xFF\xFF\xFF\x16\x90Pa3\x01V[\x81`\xFF\x16`\x08\x03a3\x01Wa2\xF4a2\x91a2\0\x87`\x01aA\xBDV[`\xC0\x1Cd\xFF\0\0\0\xFF`\x08\x82\x81\x1C\x91\x82\x16e\xFF\0\0\0\xFF\0\x93\x90\x91\x1B\x92\x83\x16\x17`\x10\x90\x81\x1Bg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16f\xFF\0\xFF\0\xFF\0\xFF\x92\x90\x92\x16g\xFF\0\xFF\0\xFF\0\xFF\0\x90\x93\x16\x92\x90\x92\x17\x90\x91\x1Ce\xFF\xFF\0\0\xFF\xFF\x16\x17` \x81\x81\x1C\x91\x90\x1B\x17\x90V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P[`\xFF\x90\x91\x16\x92P\x90P[\x92P\x92\x90PV[_a\n\xD0\x83\x83\x01` \x01Q\x90V[``\x83\x15a3/WP\x81a\n\xD0V[\x82Q\x15a3?W\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x1Ei\x91\x90aD\xB1V[_\x80a3f\x83`%aA\xBDV[\x84Q\x10\x15a3yWP_\x19\x90P_a3\x0BV[_\x80a3\x8A\x86a+\xEB\x87`$aA\xBDV[\x90\x97\x90\x96P\x94PPPPPV[_a\n\xD0\x83\x83a4>V[_a\n\xD0a3\xB1\x83`\x04aA\xBDV[\x84\x01` \x01Q\x90V[_\x82\x82\x81Q\x81\x10a3\xCDWa3\xCDa<|V[\x01` \x01Q`\xF8\x1C`\xFF\x03a3\xE4WP`\x08a\x068V[\x82\x82\x81Q\x81\x10a3\xF6Wa3\xF6a<|V[\x01` \x01Q`\xF8\x1C`\xFE\x03a4\rWP`\x04a\x068V[\x82\x82\x81Q\x81\x10a4\x1FWa4\x1Fa<|V[\x01` \x01Q`\xF8\x1C`\xFD\x03a46WP`\x02a\x068V[P_\x92\x91PPV[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[`@Q\x80`\xA0\x01`@R\x80_\x81R` \x01a4\x8C`@Q\x80` \x01`@R\x80``\x81RP\x90V[\x81R_` \x82\x01\x81\x90R`@\x82\x01\x81\x90R``\x90\x91\x01R\x90V[P\x80Ta4\xB2\x90a<1V[_\x82U\x80`\x1F\x10a4\xC1WPPV[`\x1F\x01` \x90\x04\x90_R` _ \x90\x81\x01\x90a4\xDD\x91\x90a57V[PV[`@Q\x80a\x01\0\x01`@R\x80_\x81R` \x01a5\x08`@Q\x80` \x01`@R\x80``\x81RP\x90V[\x81R_` \x82\x01\x81\x90R`@\x82\x01\x81\x90R``\x82\x01\x81\x90R`\x80\x82\x01\x81\x90R`\xA0\x82\x01\x81\x90R`\xC0\x90\x91\x01R\x90V[[\x80\x82\x11\x15a5KW_\x81U`\x01\x01a58V[P\x90V[__`@\x83\x85\x03\x12\x15a5`W__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_\x81Q` \x84Ra\x1DZ` \x85\x01\x82a5oV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a5\xE1W\x81Q\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a5\xC3V[P\x93\x94\x93PPPPV[_`@\x82\x01`@\x83R\x80\x85Q\x80\x83R``\x85\x01\x91P``\x81`\x05\x1B\x86\x01\x01\x92P` \x87\x01_[\x82\x81\x10\x15a6\xADW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x87\x86\x03\x01\x84R\x81Q\x80Q\x86R` \x81\x01Q`\xA0` \x88\x01Ra6_`\xA0\x88\x01\x82a5\x9DV[\x90P`\x01`\x01`\xA0\x1B\x03`@\x83\x01Q\x16`@\x88\x01R``\x82\x01Q``\x88\x01R`\x01`\x01`\xA0\x1B\x03`\x80\x83\x01Q\x16`\x80\x88\x01R\x80\x96PPP` \x82\x01\x91P` \x84\x01\x93P`\x01\x81\x01\x90Pa6\x11V[PPPP\x82\x81\x03` \x84\x01Ra)J\x81\x85a5\xB1V[_` \x82\x84\x03\x12\x15a6\xD3W__\xFD[P\x91\x90PV[___``\x84\x86\x03\x12\x15a6\xEBW__\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a7\x08W__\xFD[a7\x14\x86\x82\x87\x01a6\xC3V[\x93\x96\x93\x95PPPP`@\x91\x90\x91\x015\x90V[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a7\x1CWa>\x1Ca<\x04V[a>0\x81a>*\x84Ta<1V[\x84a=\xBEV[` `\x1F\x82\x11`\x01\x81\x14a>bW_\x83\x15a>KWP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x1ErV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a>\x91W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a>qV[P\x84\x82\x10\x15a>\xAEW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[\x81\x83R\x81\x81` \x85\x017P_` \x82\x84\x01\x01R_` `\x1F\x19`\x1F\x84\x01\x16\x84\x01\x01\x90P\x92\x91PPV[_\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\xFF\xE1\x836\x03\x01\x81\x12a?\x18W__\xFD[\x82\x01` \x81\x01\x905g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a?4W__\xFD[\x806\x03\x82\x13\x15a?BW__\xFD[` \x85Ra)J` \x86\x01\x82\x84a>\xBDV[`\x80\x81R_a?f`\x80\x83\x01\x87a>\xE6V[` \x83\x01\x95\x90\x95RP`@\x81\x01\x92\x90\x92R`\x01`\x01`\xA0\x1B\x03\x16``\x90\x91\x01R\x91\x90PV[\x84\x81R`\x80` \x82\x01R_a?\xA3`\x80\x83\x01\x86a>\xE6V[`\x01`\x01`\xA0\x1B\x03\x94\x90\x94\x16`@\x83\x01RP``\x01R\x92\x91PPV[__\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?\xF2W__\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a@\x0CW__\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a3\x0BW__\xFD[` \x81R_a\x1DZ` \x83\x01\x84\x86a>\xBDV[\x805\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\x14a7W__\xFD[aAJ6\x82\x86\x01a<\xD2V[\x82RP` \x83\x81\x015\x90\x82\x01R`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aApW__\xFD[aA|6\x82\x86\x01a<\xD2V[`@\x83\x01RP``\x83\x81\x015\x90\x82\x01R`\x80\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aA\xA5W__\xFD[aA\xB16\x82\x86\x01a<\xD2V[`\x80\x83\x01RP\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x068Wa\x068a;(V[\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\x83`\xF8\x1B\x16\x81R__\x83TaB\x05\x81a<1V[`\x01\x82\x16\x80\x15aB\x1CW`\x01\x81\x14aBUWaB\x8BV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x83\x16`\x01\x87\x01R`\x01\x82\x15\x15\x83\x02\x87\x01\x01\x93PaB\x8BV[\x86_R` _ _[\x83\x81\x10\x15aB\x80W\x81T`\x01\x82\x8A\x01\x01R`\x01\x82\x01\x91P` \x81\x01\x90PaB^V[PP`\x01\x82\x87\x01\x01\x93P[P\x91\x96\x95PPPPPPV[_` \x82\x84\x03\x12\x15aB\xA7W__\xFD[\x81Q\x80\x15\x15\x81\x14a\n\xD0W__\xFD[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[\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\x85\x16\x81R_aC\taC\x03`\x04\x84\x01\x87aB\xB6V[\x85aB\xB6V[\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\x93\x90\x93\x16\x83RPP`\x04\x01\x93\x92PPPV[_a\n\xD0\x82\x84aB\xB6V[_` \x82\x84\x03\x12\x15aCWW__\xFD[PQ\x91\x90PV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x068Wa\x068a;(V[_\x82aC\x8CWaC\x8Ca;lV[P\x06\x90V[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x068Wa\x068a;(V[`\x01\x81[`\x01\x84\x11\x15aC\xE5W\x80\x85\x04\x81\x11\x15aC\xC9WaC\xC9a;(V[`\x01\x84\x16\x15aC\xD7W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02aC\xAEV[\x93P\x93\x91PPV[_\x82aC\xFBWP`\x01a\x068V[\x81aD\x07WP_a\x068V[\x81`\x01\x81\x14aD\x1DW`\x02\x81\x14aD'WaDCV[`\x01\x91PPa\x068V[`\xFF\x84\x11\x15aD8WaD8a;(V[PP`\x01\x82\x1Ba\x068V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15aDfWP\x81\x81\na\x068V[aDr_\x19\x84\x84aC\xAAV[\x80_\x19\x04\x82\x11\x15aD\x85WaD\x85a;(V[\x02\x93\x92PPPV[_a\n\xD0\x83\x83aC\xEDV[`\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x068Wa\x068a;(V[` \x81R_a\n\xD0` \x83\x01\x84a5oV\xFE\xA2dipfsX\"\x12 A\xDF\x18\xE5x\xA0A\xC2\xE5-\x8F\x05\xEBc;\xA9l\0\x11;`\x87?x\xCB\xE1J\xFF\x1C\xB1\x7F\x07dsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct AcceptedBtcBuyOrder { uint256 orderId; uint256 amountBtc; address ercToken; uint256 ercAmount; address requester; address accepter; uint256 acceptTime; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct AcceptedBtcBuyOrder { + #[allow(missing_docs)] + pub orderId: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub ercToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub ercAmount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub requester: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub accepter: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub acceptTime: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + 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::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::Address, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: AcceptedBtcBuyOrder) -> Self { + ( + value.orderId, + value.amountBtc, + value.ercToken, + value.ercAmount, + value.requester, + value.accepter, + value.acceptTime, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for AcceptedBtcBuyOrder { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + orderId: tuple.0, + amountBtc: tuple.1, + ercToken: tuple.2, + ercAmount: tuple.3, + requester: tuple.4, + accepter: tuple.5, + acceptTime: tuple.6, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for AcceptedBtcBuyOrder { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for AcceptedBtcBuyOrder { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.orderId), + as alloy_sol_types::SolType>::tokenize(&self.amountBtc), + ::tokenize( + &self.ercToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.ercAmount), + ::tokenize( + &self.requester, + ), + ::tokenize( + &self.accepter, + ), + as alloy_sol_types::SolType>::tokenize(&self.acceptTime), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for AcceptedBtcBuyOrder { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for AcceptedBtcBuyOrder { + const NAME: &'static str = "AcceptedBtcBuyOrder"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "AcceptedBtcBuyOrder(uint256 orderId,uint256 amountBtc,address ercToken,uint256 ercAmount,address requester,address accepter,uint256 acceptTime)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + as alloy_sol_types::SolType>::eip712_data_word(&self.orderId) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.amountBtc) + .0, + ::eip712_data_word( + &self.ercToken, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.ercAmount) + .0, + ::eip712_data_word( + &self.requester, + ) + .0, + ::eip712_data_word( + &self.accepter, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.acceptTime) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for AcceptedBtcBuyOrder { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.orderId, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.amountBtc, + ) + + ::topic_preimage_length( + &rust.ercToken, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.ercAmount, + ) + + ::topic_preimage_length( + &rust.requester, + ) + + ::topic_preimage_length( + &rust.accepter, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.acceptTime, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.orderId, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.amountBtc, + out, + ); + ::encode_topic_preimage( + &rust.ercToken, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.ercAmount, + out, + ); + ::encode_topic_preimage( + &rust.requester, + out, + ); + ::encode_topic_preimage( + &rust.accepter, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.acceptTime, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct AcceptedBtcSellOrder { uint256 orderId; BitcoinAddress bitcoinAddress; uint256 amountBtc; address ercToken; uint256 ercAmount; address requester; address accepter; uint256 acceptTime; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct AcceptedBtcSellOrder { + #[allow(missing_docs)] + pub orderId: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub bitcoinAddress: ::RustType, + #[allow(missing_docs)] + pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub ercToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub ercAmount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub requester: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub accepter: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub acceptTime: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + BitcoinAddress, + 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::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ::RustType, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Address, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: AcceptedBtcSellOrder) -> Self { + ( + value.orderId, + value.bitcoinAddress, + value.amountBtc, + value.ercToken, + value.ercAmount, + value.requester, + value.accepter, + value.acceptTime, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for AcceptedBtcSellOrder { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + orderId: tuple.0, + bitcoinAddress: tuple.1, + amountBtc: tuple.2, + ercToken: tuple.3, + ercAmount: tuple.4, + requester: tuple.5, + accepter: tuple.6, + acceptTime: tuple.7, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for AcceptedBtcSellOrder { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for AcceptedBtcSellOrder { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.orderId), + ::tokenize( + &self.bitcoinAddress, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountBtc), + ::tokenize( + &self.ercToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.ercAmount), + ::tokenize( + &self.requester, + ), + ::tokenize( + &self.accepter, + ), + as alloy_sol_types::SolType>::tokenize(&self.acceptTime), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for AcceptedBtcSellOrder { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for AcceptedBtcSellOrder { + const NAME: &'static str = "AcceptedBtcSellOrder"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "AcceptedBtcSellOrder(uint256 orderId,BitcoinAddress bitcoinAddress,uint256 amountBtc,address ercToken,uint256 ercAmount,address requester,address accepter,uint256 acceptTime)", + ) + } + #[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( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + as alloy_sol_types::SolType>::eip712_data_word(&self.orderId) + .0, + ::eip712_data_word( + &self.bitcoinAddress, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.amountBtc) + .0, + ::eip712_data_word( + &self.ercToken, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.ercAmount) + .0, + ::eip712_data_word( + &self.requester, + ) + .0, + ::eip712_data_word( + &self.accepter, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.acceptTime) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for AcceptedBtcSellOrder { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.orderId, + ) + + ::topic_preimage_length( + &rust.bitcoinAddress, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.amountBtc, + ) + + ::topic_preimage_length( + &rust.ercToken, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.ercAmount, + ) + + ::topic_preimage_length( + &rust.requester, + ) + + ::topic_preimage_length( + &rust.accepter, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.acceptTime, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.orderId, + out, + ); + ::encode_topic_preimage( + &rust.bitcoinAddress, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.amountBtc, + out, + ); + ::encode_topic_preimage( + &rust.ercToken, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.ercAmount, + out, + ); + ::encode_topic_preimage( + &rust.requester, + out, + ); + ::encode_topic_preimage( + &rust.accepter, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.acceptTime, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct BitcoinAddress { bytes scriptPubKey; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct BitcoinAddress { + #[allow(missing_docs)] + pub scriptPubKey: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: BitcoinAddress) -> Self { + (value.scriptPubKey,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for BitcoinAddress { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { scriptPubKey: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for BitcoinAddress { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for BitcoinAddress { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.scriptPubKey, + ), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for BitcoinAddress { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for BitcoinAddress { + const NAME: &'static str = "BitcoinAddress"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "BitcoinAddress(bytes scriptPubKey)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + ::eip712_data_word( + &self.scriptPubKey, + ) + .0 + .to_vec() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for BitcoinAddress { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.scriptPubKey, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.scriptPubKey, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct BtcBuyOrder { uint256 amountBtc; BitcoinAddress bitcoinAddress; address offeringToken; uint256 offeringAmount; address requester; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct BtcBuyOrder { + #[allow(missing_docs)] + pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub bitcoinAddress: ::RustType, + #[allow(missing_docs)] + pub offeringToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub offeringAmount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub requester: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + BitcoinAddress, + 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, + ::RustType, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: BtcBuyOrder) -> Self { + ( + value.amountBtc, + value.bitcoinAddress, + value.offeringToken, + value.offeringAmount, + value.requester, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for BtcBuyOrder { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + amountBtc: tuple.0, + bitcoinAddress: tuple.1, + offeringToken: tuple.2, + offeringAmount: tuple.3, + requester: tuple.4, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for BtcBuyOrder { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for BtcBuyOrder { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountBtc), + ::tokenize( + &self.bitcoinAddress, + ), + ::tokenize( + &self.offeringToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.offeringAmount), + ::tokenize( + &self.requester, + ), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for BtcBuyOrder { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for BtcBuyOrder { + const NAME: &'static str = "BtcBuyOrder"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "BtcBuyOrder(uint256 amountBtc,BitcoinAddress bitcoinAddress,address offeringToken,uint256 offeringAmount,address requester)", + ) + } + #[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( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + as alloy_sol_types::SolType>::eip712_data_word(&self.amountBtc) + .0, + ::eip712_data_word( + &self.bitcoinAddress, + ) + .0, + ::eip712_data_word( + &self.offeringToken, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word( + &self.offeringAmount, + ) + .0, + ::eip712_data_word( + &self.requester, + ) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for BtcBuyOrder { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.amountBtc, + ) + + ::topic_preimage_length( + &rust.bitcoinAddress, + ) + + ::topic_preimage_length( + &rust.offeringToken, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.offeringAmount, + ) + + ::topic_preimage_length( + &rust.requester, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.amountBtc, + out, + ); + ::encode_topic_preimage( + &rust.bitcoinAddress, + out, + ); + ::encode_topic_preimage( + &rust.offeringToken, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.offeringAmount, + out, + ); + ::encode_topic_preimage( + &rust.requester, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct BtcSellOrder { uint256 amountBtc; address askingToken; uint256 askingAmount; address requester; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct BtcSellOrder { + #[allow(missing_docs)] + pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub askingToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub askingAmount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub requester: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + 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, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: BtcSellOrder) -> Self { + (value.amountBtc, value.askingToken, value.askingAmount, value.requester) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for BtcSellOrder { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + amountBtc: tuple.0, + askingToken: tuple.1, + askingAmount: tuple.2, + requester: tuple.3, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for BtcSellOrder { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for BtcSellOrder { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountBtc), + ::tokenize( + &self.askingToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.askingAmount), + ::tokenize( + &self.requester, + ), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for BtcSellOrder { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for BtcSellOrder { + const NAME: &'static str = "BtcSellOrder"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "BtcSellOrder(uint256 amountBtc,address askingToken,uint256 askingAmount,address requester)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + as alloy_sol_types::SolType>::eip712_data_word(&self.amountBtc) + .0, + ::eip712_data_word( + &self.askingToken, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.askingAmount) + .0, + ::eip712_data_word( + &self.requester, + ) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for BtcSellOrder { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.amountBtc, + ) + + ::topic_preimage_length( + &rust.askingToken, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.askingAmount, + ) + + ::topic_preimage_length( + &rust.requester, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.amountBtc, + out, + ); + ::encode_topic_preimage( + &rust.askingToken, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.askingAmount, + out, + ); + ::encode_topic_preimage( + &rust.requester, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `acceptBtcBuyOrderEvent(uint256,uint256,uint256,uint256,address)` and selector `0xc39a1a5ddc0e85c955fe2e1abeb43c94ce18322e75bb3d44e80f759ff9d034b9`. +```solidity +event acceptBtcBuyOrderEvent(uint256 indexed orderId, uint256 indexed acceptId, uint256 amountBtc, uint256 ercAmount, address ercToken); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct acceptBtcBuyOrderEvent { + #[allow(missing_docs)] + pub orderId: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub acceptId: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub ercAmount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub ercToken: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for acceptBtcBuyOrderEvent { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + const SIGNATURE: &'static str = "acceptBtcBuyOrderEvent(uint256,uint256,uint256,uint256,address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 195u8, 154u8, 26u8, 93u8, 220u8, 14u8, 133u8, 201u8, 85u8, 254u8, 46u8, + 26u8, 190u8, 180u8, 60u8, 148u8, 206u8, 24u8, 50u8, 46u8, 117u8, 187u8, + 61u8, 68u8, 232u8, 15u8, 117u8, 159u8, 249u8, 208u8, 52u8, 185u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + orderId: topics.1, + acceptId: topics.2, + amountBtc: data.0, + ercAmount: data.1, + ercToken: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountBtc), + as alloy_sol_types::SolType>::tokenize(&self.ercAmount), + ::tokenize( + &self.ercToken, + ), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + ( + Self::SIGNATURE_HASH.into(), + self.orderId.clone(), + self.acceptId.clone(), + ) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.orderId); + out[2usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.acceptId); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for acceptBtcBuyOrderEvent { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&acceptBtcBuyOrderEvent> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &acceptBtcBuyOrderEvent) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `acceptBtcSellOrderEvent(uint256,uint256,(bytes),uint256,uint256,address)` and selector `0x653e0d81f2c99beba359dfb17b499a5cff2be9d950514852224df8c097c21921`. +```solidity +event acceptBtcSellOrderEvent(uint256 indexed id, uint256 indexed acceptId, BitcoinAddress bitcoinAddress, uint256 amountBtc, uint256 ercAmount, address ercToken); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct acceptBtcSellOrderEvent { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub acceptId: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub bitcoinAddress: ::RustType, + #[allow(missing_docs)] + pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub ercAmount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub ercToken: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for acceptBtcSellOrderEvent { + type DataTuple<'a> = ( + BitcoinAddress, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + const SIGNATURE: &'static str = "acceptBtcSellOrderEvent(uint256,uint256,(bytes),uint256,uint256,address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 101u8, 62u8, 13u8, 129u8, 242u8, 201u8, 155u8, 235u8, 163u8, 89u8, 223u8, + 177u8, 123u8, 73u8, 154u8, 92u8, 255u8, 43u8, 233u8, 217u8, 80u8, 81u8, + 72u8, 82u8, 34u8, 77u8, 248u8, 192u8, 151u8, 194u8, 25u8, 33u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + id: topics.1, + acceptId: topics.2, + bitcoinAddress: data.0, + amountBtc: data.1, + ercAmount: data.2, + ercToken: data.3, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.bitcoinAddress, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountBtc), + as alloy_sol_types::SolType>::tokenize(&self.ercAmount), + ::tokenize( + &self.ercToken, + ), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.id.clone(), self.acceptId.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.id); + out[2usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.acceptId); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for acceptBtcSellOrderEvent { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&acceptBtcSellOrderEvent> for alloy_sol_types::private::LogData { + #[inline] + fn from( + this: &acceptBtcSellOrderEvent, + ) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `cancelAcceptedBtcBuyOrderEvent(uint256)` and selector `0x3e5ea358e9eb4cdf44cdc77938ade8074b1240a6d8c0fd13728671b82e800ad6`. +```solidity +event cancelAcceptedBtcBuyOrderEvent(uint256 id); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct cancelAcceptedBtcBuyOrderEvent { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for cancelAcceptedBtcBuyOrderEvent { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "cancelAcceptedBtcBuyOrderEvent(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 62u8, 94u8, 163u8, 88u8, 233u8, 235u8, 76u8, 223u8, 68u8, 205u8, 199u8, + 121u8, 56u8, 173u8, 232u8, 7u8, 75u8, 18u8, 64u8, 166u8, 216u8, 192u8, + 253u8, 19u8, 114u8, 134u8, 113u8, 184u8, 46u8, 128u8, 10u8, 214u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { id: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 cancelAcceptedBtcBuyOrderEvent { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&cancelAcceptedBtcBuyOrderEvent> + for alloy_sol_types::private::LogData { + #[inline] + fn from( + this: &cancelAcceptedBtcBuyOrderEvent, + ) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `cancelAcceptedBtcSellOrderEvent(uint256)` and selector `0x78f51f62f7cf1381c673c27eae187dd6c588dc6624ce59697dbb3e1d7c1bbcdf`. +```solidity +event cancelAcceptedBtcSellOrderEvent(uint256 id); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct cancelAcceptedBtcSellOrderEvent { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for cancelAcceptedBtcSellOrderEvent { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "cancelAcceptedBtcSellOrderEvent(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 120u8, 245u8, 31u8, 98u8, 247u8, 207u8, 19u8, 129u8, 198u8, 115u8, 194u8, + 126u8, 174u8, 24u8, 125u8, 214u8, 197u8, 136u8, 220u8, 102u8, 36u8, + 206u8, 89u8, 105u8, 125u8, 187u8, 62u8, 29u8, 124u8, 27u8, 188u8, 223u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { id: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 cancelAcceptedBtcSellOrderEvent { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&cancelAcceptedBtcSellOrderEvent> + for alloy_sol_types::private::LogData { + #[inline] + fn from( + this: &cancelAcceptedBtcSellOrderEvent, + ) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `placeBtcBuyOrderEvent(uint256,(bytes),address,uint256)` and selector `0x98c7c680403d47403dea4a570d0e6c5716538c49420ef471cec428f5a5852c06`. +```solidity +event placeBtcBuyOrderEvent(uint256 amountBtc, BitcoinAddress bitcoinAddress, address sellingToken, uint256 saleAmount); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct placeBtcBuyOrderEvent { + #[allow(missing_docs)] + pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub bitcoinAddress: ::RustType, + #[allow(missing_docs)] + pub sellingToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub saleAmount: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for placeBtcBuyOrderEvent { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + BitcoinAddress, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "placeBtcBuyOrderEvent(uint256,(bytes),address,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 152u8, 199u8, 198u8, 128u8, 64u8, 61u8, 71u8, 64u8, 61u8, 234u8, 74u8, + 87u8, 13u8, 14u8, 108u8, 87u8, 22u8, 83u8, 140u8, 73u8, 66u8, 14u8, + 244u8, 113u8, 206u8, 196u8, 40u8, 245u8, 165u8, 133u8, 44u8, 6u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + amountBtc: data.0, + bitcoinAddress: data.1, + sellingToken: data.2, + saleAmount: data.3, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountBtc), + ::tokenize( + &self.bitcoinAddress, + ), + ::tokenize( + &self.sellingToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.saleAmount), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 placeBtcBuyOrderEvent { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&placeBtcBuyOrderEvent> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &placeBtcBuyOrderEvent) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `placeBtcSellOrderEvent(uint256,uint256,address,uint256)` and selector `0xff1ce210defcd3ba1adf76c9419a0758fa60fd3eb38c7bd9418f60b575b76e24`. +```solidity +event placeBtcSellOrderEvent(uint256 indexed orderId, uint256 amountBtc, address buyingToken, uint256 buyAmount); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct placeBtcSellOrderEvent { + #[allow(missing_docs)] + pub orderId: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub buyingToken: alloy::sol_types::private::Address, + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for placeBtcSellOrderEvent { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + ); + const SIGNATURE: &'static str = "placeBtcSellOrderEvent(uint256,uint256,address,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 255u8, 28u8, 226u8, 16u8, 222u8, 252u8, 211u8, 186u8, 26u8, 223u8, 118u8, + 201u8, 65u8, 154u8, 7u8, 88u8, 250u8, 96u8, 253u8, 62u8, 179u8, 140u8, + 123u8, 217u8, 65u8, 143u8, 96u8, 181u8, 117u8, 183u8, 110u8, 36u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + orderId: topics.1, + amountBtc: data.0, + buyingToken: data.1, + buyAmount: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountBtc), + ::tokenize( + &self.buyingToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.buyAmount), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.orderId.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.orderId); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for placeBtcSellOrderEvent { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&placeBtcSellOrderEvent> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &placeBtcSellOrderEvent) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `proofBtcBuyOrderEvent(uint256)` and selector `0xb4c98de210696b3cf21e99335c1ee3a0ae34a26713412a4adde8af596176f37e`. +```solidity +event proofBtcBuyOrderEvent(uint256 id); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct proofBtcBuyOrderEvent { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for proofBtcBuyOrderEvent { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "proofBtcBuyOrderEvent(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 180u8, 201u8, 141u8, 226u8, 16u8, 105u8, 107u8, 60u8, 242u8, 30u8, 153u8, + 51u8, 92u8, 30u8, 227u8, 160u8, 174u8, 52u8, 162u8, 103u8, 19u8, 65u8, + 42u8, 74u8, 221u8, 232u8, 175u8, 89u8, 97u8, 118u8, 243u8, 126u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { id: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 proofBtcBuyOrderEvent { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&proofBtcBuyOrderEvent> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &proofBtcBuyOrderEvent) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `proofBtcSellOrderEvent(uint256)` and selector `0xcf561061db78f7bc518d37fe86718514c640ccc5c3f1293828b955e68f19f5fb`. +```solidity +event proofBtcSellOrderEvent(uint256 id); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct proofBtcSellOrderEvent { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for proofBtcSellOrderEvent { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "proofBtcSellOrderEvent(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 207u8, 86u8, 16u8, 97u8, 219u8, 120u8, 247u8, 188u8, 81u8, 141u8, 55u8, + 254u8, 134u8, 113u8, 133u8, 20u8, 198u8, 64u8, 204u8, 197u8, 195u8, + 241u8, 41u8, 56u8, 40u8, 185u8, 85u8, 230u8, 143u8, 25u8, 245u8, 251u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { id: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 proofBtcSellOrderEvent { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&proofBtcSellOrderEvent> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &proofBtcSellOrderEvent) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `withdrawBtcBuyOrderEvent(uint256)` and selector `0xc340e7ac48dc80ee793fc6266960bd5f1bd21be91c8a95e218178113f79e17b4`. +```solidity +event withdrawBtcBuyOrderEvent(uint256 id); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct withdrawBtcBuyOrderEvent { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for withdrawBtcBuyOrderEvent { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "withdrawBtcBuyOrderEvent(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 195u8, 64u8, 231u8, 172u8, 72u8, 220u8, 128u8, 238u8, 121u8, 63u8, 198u8, + 38u8, 105u8, 96u8, 189u8, 95u8, 27u8, 210u8, 27u8, 233u8, 28u8, 138u8, + 149u8, 226u8, 24u8, 23u8, 129u8, 19u8, 247u8, 158u8, 23u8, 180u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { id: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 withdrawBtcBuyOrderEvent { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&withdrawBtcBuyOrderEvent> for alloy_sol_types::private::LogData { + #[inline] + fn from( + this: &withdrawBtcBuyOrderEvent, + ) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `withdrawBtcSellOrderEvent(uint256)` and selector `0x3cd475b092e8b379f6ba0d9e0e0c8f30705e73321dc5c9f80ce4ad38db7be1aa`. +```solidity +event withdrawBtcSellOrderEvent(uint256 id); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct withdrawBtcSellOrderEvent { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for withdrawBtcSellOrderEvent { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "withdrawBtcSellOrderEvent(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 60u8, 212u8, 117u8, 176u8, 146u8, 232u8, 179u8, 121u8, 246u8, 186u8, + 13u8, 158u8, 14u8, 12u8, 143u8, 48u8, 112u8, 94u8, 115u8, 50u8, 29u8, + 197u8, 201u8, 248u8, 12u8, 228u8, 173u8, 56u8, 219u8, 123u8, 225u8, 170u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { id: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 withdrawBtcSellOrderEvent { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&withdrawBtcSellOrderEvent> for alloy_sol_types::private::LogData { + #[inline] + fn from( + this: &withdrawBtcSellOrderEvent, + ) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(address _relay, address erc2771Forwarder); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _relay: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub erc2771Forwarder: alloy::sol_types::private::Address, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._relay, value.erc2771Forwarder) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _relay: tuple.0, + erc2771Forwarder: 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> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._relay, + ), + ::tokenize( + &self.erc2771Forwarder, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `REQUEST_EXPIRATION_SECONDS()` and selector `0xd1920ff0`. +```solidity +function REQUEST_EXPIRATION_SECONDS() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct REQUEST_EXPIRATION_SECONDSCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`REQUEST_EXPIRATION_SECONDS()`](REQUEST_EXPIRATION_SECONDSCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct REQUEST_EXPIRATION_SECONDSReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: REQUEST_EXPIRATION_SECONDSCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for REQUEST_EXPIRATION_SECONDSCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: REQUEST_EXPIRATION_SECONDSReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for REQUEST_EXPIRATION_SECONDSReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for REQUEST_EXPIRATION_SECONDSCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "REQUEST_EXPIRATION_SECONDS()"; + const SELECTOR: [u8; 4] = [209u8, 146u8, 15u8, 240u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: REQUEST_EXPIRATION_SECONDSReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: REQUEST_EXPIRATION_SECONDSReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `acceptBtcBuyOrder(uint256,uint256)` and selector `0x11c137aa`. +```solidity +function acceptBtcBuyOrder(uint256 id, uint256 amountBtc) external returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct acceptBtcBuyOrderCall { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`acceptBtcBuyOrder(uint256,uint256)`](acceptBtcBuyOrderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct acceptBtcBuyOrderReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: acceptBtcBuyOrderCall) -> Self { + (value.id, value.amountBtc) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for acceptBtcBuyOrderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + id: tuple.0, + amountBtc: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: acceptBtcBuyOrderReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for acceptBtcBuyOrderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for acceptBtcBuyOrderCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "acceptBtcBuyOrder(uint256,uint256)"; + const SELECTOR: [u8; 4] = [17u8, 193u8, 55u8, 170u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + as alloy_sol_types::SolType>::tokenize(&self.amountBtc), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: acceptBtcBuyOrderReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: acceptBtcBuyOrderReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `acceptBtcSellOrder(uint256,(bytes),uint256)` and selector `0x210ec181`. +```solidity +function acceptBtcSellOrder(uint256 id, BitcoinAddress memory bitcoinAddress, uint256 amountBtc) external returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct acceptBtcSellOrderCall { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub bitcoinAddress: ::RustType, + #[allow(missing_docs)] + pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`acceptBtcSellOrder(uint256,(bytes),uint256)`](acceptBtcSellOrderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct acceptBtcSellOrderReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + BitcoinAddress, + alloy::sol_types::sol_data::Uint<256>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ::RustType, + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: acceptBtcSellOrderCall) -> Self { + (value.id, value.bitcoinAddress, value.amountBtc) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for acceptBtcSellOrderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + id: tuple.0, + bitcoinAddress: tuple.1, + amountBtc: tuple.2, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: acceptBtcSellOrderReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for acceptBtcSellOrderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for acceptBtcSellOrderCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + BitcoinAddress, + alloy::sol_types::sol_data::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "acceptBtcSellOrder(uint256,(bytes),uint256)"; + const SELECTOR: [u8; 4] = [33u8, 14u8, 193u8, 129u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + ::tokenize( + &self.bitcoinAddress, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountBtc), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: acceptBtcSellOrderReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: acceptBtcSellOrderReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `acceptedBtcBuyOrders(uint256)` and selector `0xbd2a7e3e`. +```solidity +function acceptedBtcBuyOrders(uint256) external view returns (uint256 orderId, uint256 amountBtc, address ercToken, uint256 ercAmount, address requester, address accepter, uint256 acceptTime); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct acceptedBtcBuyOrdersCall( + pub alloy::sol_types::private::primitives::aliases::U256, + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`acceptedBtcBuyOrders(uint256)`](acceptedBtcBuyOrdersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct acceptedBtcBuyOrdersReturn { + #[allow(missing_docs)] + pub orderId: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub ercToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub ercAmount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub requester: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub accepter: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub acceptTime: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: acceptedBtcBuyOrdersCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for acceptedBtcBuyOrdersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + 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::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::Address, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: acceptedBtcBuyOrdersReturn) -> Self { + ( + value.orderId, + value.amountBtc, + value.ercToken, + value.ercAmount, + value.requester, + value.accepter, + value.acceptTime, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for acceptedBtcBuyOrdersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + orderId: tuple.0, + amountBtc: tuple.1, + ercToken: tuple.2, + ercAmount: tuple.3, + requester: tuple.4, + accepter: tuple.5, + acceptTime: tuple.6, + } + } + } + } + impl acceptedBtcBuyOrdersReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + ( + as alloy_sol_types::SolType>::tokenize(&self.orderId), + as alloy_sol_types::SolType>::tokenize(&self.amountBtc), + ::tokenize( + &self.ercToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.ercAmount), + ::tokenize( + &self.requester, + ), + ::tokenize( + &self.accepter, + ), + as alloy_sol_types::SolType>::tokenize(&self.acceptTime), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for acceptedBtcBuyOrdersCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = acceptedBtcBuyOrdersReturn; + type ReturnTuple<'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::Address, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "acceptedBtcBuyOrders(uint256)"; + const SELECTOR: [u8; 4] = [189u8, 42u8, 126u8, 62u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.0), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + acceptedBtcBuyOrdersReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `acceptedBtcSellOrders(uint256)` and selector `0x4145640a`. +```solidity +function acceptedBtcSellOrders(uint256) external view returns (uint256 orderId, BitcoinAddress memory bitcoinAddress, uint256 amountBtc, address ercToken, uint256 ercAmount, address requester, address accepter, uint256 acceptTime); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct acceptedBtcSellOrdersCall( + pub alloy::sol_types::private::primitives::aliases::U256, + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`acceptedBtcSellOrders(uint256)`](acceptedBtcSellOrdersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct acceptedBtcSellOrdersReturn { + #[allow(missing_docs)] + pub orderId: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub bitcoinAddress: ::RustType, + #[allow(missing_docs)] + pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub ercToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub ercAmount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub requester: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub accepter: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub acceptTime: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: acceptedBtcSellOrdersCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for acceptedBtcSellOrdersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + BitcoinAddress, + 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::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ::RustType, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Address, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: acceptedBtcSellOrdersReturn) -> Self { + ( + value.orderId, + value.bitcoinAddress, + value.amountBtc, + value.ercToken, + value.ercAmount, + value.requester, + value.accepter, + value.acceptTime, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for acceptedBtcSellOrdersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + orderId: tuple.0, + bitcoinAddress: tuple.1, + amountBtc: tuple.2, + ercToken: tuple.3, + ercAmount: tuple.4, + requester: tuple.5, + accepter: tuple.6, + acceptTime: tuple.7, + } + } + } + } + impl acceptedBtcSellOrdersReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + ( + as alloy_sol_types::SolType>::tokenize(&self.orderId), + ::tokenize( + &self.bitcoinAddress, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountBtc), + ::tokenize( + &self.ercToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.ercAmount), + ::tokenize( + &self.requester, + ), + ::tokenize( + &self.accepter, + ), + as alloy_sol_types::SolType>::tokenize(&self.acceptTime), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for acceptedBtcSellOrdersCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = acceptedBtcSellOrdersReturn; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + BitcoinAddress, + 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::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "acceptedBtcSellOrders(uint256)"; + const SELECTOR: [u8; 4] = [65u8, 69u8, 100u8, 10u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.0), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + acceptedBtcSellOrdersReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `btcBuyOrders(uint256)` and selector `0x3af3fc7e`. +```solidity +function btcBuyOrders(uint256) external view returns (uint256 amountBtc, BitcoinAddress memory bitcoinAddress, address offeringToken, uint256 offeringAmount, address requester); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct btcBuyOrdersCall( + pub alloy::sol_types::private::primitives::aliases::U256, + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`btcBuyOrders(uint256)`](btcBuyOrdersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct btcBuyOrdersReturn { + #[allow(missing_docs)] + pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub bitcoinAddress: ::RustType, + #[allow(missing_docs)] + pub offeringToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub offeringAmount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub requester: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: btcBuyOrdersCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for btcBuyOrdersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + BitcoinAddress, + 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, + ::RustType, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: btcBuyOrdersReturn) -> Self { + ( + value.amountBtc, + value.bitcoinAddress, + value.offeringToken, + value.offeringAmount, + value.requester, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for btcBuyOrdersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + amountBtc: tuple.0, + bitcoinAddress: tuple.1, + offeringToken: tuple.2, + offeringAmount: tuple.3, + requester: tuple.4, + } + } + } + } + impl btcBuyOrdersReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountBtc), + ::tokenize( + &self.bitcoinAddress, + ), + ::tokenize( + &self.offeringToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.offeringAmount), + ::tokenize( + &self.requester, + ), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for btcBuyOrdersCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = btcBuyOrdersReturn; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + BitcoinAddress, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "btcBuyOrders(uint256)"; + const SELECTOR: [u8; 4] = [58u8, 243u8, 252u8, 126u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.0), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + btcBuyOrdersReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `btcSellOrders(uint256)` and selector `0xecca2c36`. +```solidity +function btcSellOrders(uint256) external view returns (uint256 amountBtc, address askingToken, uint256 askingAmount, address requester); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct btcSellOrdersCall( + pub alloy::sol_types::private::primitives::aliases::U256, + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`btcSellOrders(uint256)`](btcSellOrdersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct btcSellOrdersReturn { + #[allow(missing_docs)] + pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub askingToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub askingAmount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub requester: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: btcSellOrdersCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for btcSellOrdersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + 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, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: btcSellOrdersReturn) -> Self { + ( + value.amountBtc, + value.askingToken, + value.askingAmount, + value.requester, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for btcSellOrdersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + amountBtc: tuple.0, + askingToken: tuple.1, + askingAmount: tuple.2, + requester: tuple.3, + } + } + } + } + impl btcSellOrdersReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountBtc), + ::tokenize( + &self.askingToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.askingAmount), + ::tokenize( + &self.requester, + ), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for btcSellOrdersCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = btcSellOrdersReturn; + type ReturnTuple<'a> = ( + 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 ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "btcSellOrders(uint256)"; + const SELECTOR: [u8; 4] = [236u8, 202u8, 44u8, 54u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.0), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + btcSellOrdersReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `cancelAcceptedBtcBuyOrder(uint256)` and selector `0xc56a4526`. +```solidity +function cancelAcceptedBtcBuyOrder(uint256 id) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct cancelAcceptedBtcBuyOrderCall { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`cancelAcceptedBtcBuyOrder(uint256)`](cancelAcceptedBtcBuyOrderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct cancelAcceptedBtcBuyOrderReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: cancelAcceptedBtcBuyOrderCall) -> Self { + (value.id,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for cancelAcceptedBtcBuyOrderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { id: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: cancelAcceptedBtcBuyOrderReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for cancelAcceptedBtcBuyOrderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl cancelAcceptedBtcBuyOrderReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for cancelAcceptedBtcBuyOrderCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = cancelAcceptedBtcBuyOrderReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "cancelAcceptedBtcBuyOrder(uint256)"; + const SELECTOR: [u8; 4] = [197u8, 106u8, 69u8, 38u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + cancelAcceptedBtcBuyOrderReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `cancelAcceptedBtcSellOrder(uint256)` and selector `0xdf69b14f`. +```solidity +function cancelAcceptedBtcSellOrder(uint256 id) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct cancelAcceptedBtcSellOrderCall { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`cancelAcceptedBtcSellOrder(uint256)`](cancelAcceptedBtcSellOrderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct cancelAcceptedBtcSellOrderReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: cancelAcceptedBtcSellOrderCall) -> Self { + (value.id,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for cancelAcceptedBtcSellOrderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { id: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: cancelAcceptedBtcSellOrderReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for cancelAcceptedBtcSellOrderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl cancelAcceptedBtcSellOrderReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for cancelAcceptedBtcSellOrderCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = cancelAcceptedBtcSellOrderReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "cancelAcceptedBtcSellOrder(uint256)"; + const SELECTOR: [u8; 4] = [223u8, 105u8, 177u8, 79u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + cancelAcceptedBtcSellOrderReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `getOpenAcceptedBtcBuyOrders()` and selector `0x6a8cde3a`. +```solidity +function getOpenAcceptedBtcBuyOrders() external view returns (AcceptedBtcBuyOrder[] memory, uint256[] memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getOpenAcceptedBtcBuyOrdersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`getOpenAcceptedBtcBuyOrders()`](getOpenAcceptedBtcBuyOrdersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getOpenAcceptedBtcBuyOrdersReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Vec< + ::RustType, + >, + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getOpenAcceptedBtcBuyOrdersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getOpenAcceptedBtcBuyOrdersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getOpenAcceptedBtcBuyOrdersReturn) -> Self { + (value._0, value._1) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getOpenAcceptedBtcBuyOrdersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0, _1: tuple.1 } + } + } + } + impl getOpenAcceptedBtcBuyOrdersReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + , + > as alloy_sol_types::SolType>::tokenize(&self._1), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getOpenAcceptedBtcBuyOrdersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = getOpenAcceptedBtcBuyOrdersReturn; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array>, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getOpenAcceptedBtcBuyOrders()"; + const SELECTOR: [u8; 4] = [106u8, 140u8, 222u8, 58u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + getOpenAcceptedBtcBuyOrdersReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `getOpenAcceptedBtcSellOrders()` and selector `0x9cc6722e`. +```solidity +function getOpenAcceptedBtcSellOrders() external view returns (AcceptedBtcSellOrder[] memory, uint256[] memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getOpenAcceptedBtcSellOrdersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`getOpenAcceptedBtcSellOrders()`](getOpenAcceptedBtcSellOrdersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getOpenAcceptedBtcSellOrdersReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Vec< + ::RustType, + >, + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getOpenAcceptedBtcSellOrdersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getOpenAcceptedBtcSellOrdersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getOpenAcceptedBtcSellOrdersReturn) -> Self { + (value._0, value._1) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getOpenAcceptedBtcSellOrdersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0, _1: tuple.1 } + } + } + } + impl getOpenAcceptedBtcSellOrdersReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + , + > as alloy_sol_types::SolType>::tokenize(&self._1), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getOpenAcceptedBtcSellOrdersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = getOpenAcceptedBtcSellOrdersReturn; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array>, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getOpenAcceptedBtcSellOrders()"; + const SELECTOR: [u8; 4] = [156u8, 198u8, 114u8, 46u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + getOpenAcceptedBtcSellOrdersReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `getOpenBtcBuyOrders()` and selector `0x1dfe7595`. +```solidity +function getOpenBtcBuyOrders() external view returns (BtcBuyOrder[] memory, uint256[] memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getOpenBtcBuyOrdersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`getOpenBtcBuyOrders()`](getOpenBtcBuyOrdersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getOpenBtcBuyOrdersReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Vec< + ::RustType, + >, + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getOpenBtcBuyOrdersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getOpenBtcBuyOrdersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getOpenBtcBuyOrdersReturn) -> Self { + (value._0, value._1) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getOpenBtcBuyOrdersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0, _1: tuple.1 } + } + } + } + impl getOpenBtcBuyOrdersReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + , + > as alloy_sol_types::SolType>::tokenize(&self._1), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getOpenBtcBuyOrdersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = getOpenBtcBuyOrdersReturn; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array>, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getOpenBtcBuyOrders()"; + const SELECTOR: [u8; 4] = [29u8, 254u8, 117u8, 149u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + getOpenBtcBuyOrdersReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `getOpenBtcSellOrders()` and selector `0x6811a311`. +```solidity +function getOpenBtcSellOrders() external view returns (BtcSellOrder[] memory, uint256[] memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getOpenBtcSellOrdersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`getOpenBtcSellOrders()`](getOpenBtcSellOrdersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getOpenBtcSellOrdersReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Vec< + ::RustType, + >, + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getOpenBtcSellOrdersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getOpenBtcSellOrdersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getOpenBtcSellOrdersReturn) -> Self { + (value._0, value._1) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getOpenBtcSellOrdersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0, _1: tuple.1 } + } + } + } + impl getOpenBtcSellOrdersReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + , + > as alloy_sol_types::SolType>::tokenize(&self._1), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getOpenBtcSellOrdersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = getOpenBtcSellOrdersReturn; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array>, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getOpenBtcSellOrders()"; + const SELECTOR: [u8; 4] = [104u8, 17u8, 163u8, 17u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + getOpenBtcSellOrdersReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `getTrustedForwarder()` and selector `0xce1b815f`. +```solidity +function getTrustedForwarder() external view returns (address forwarder); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getTrustedForwarderCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`getTrustedForwarder()`](getTrustedForwarderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getTrustedForwarderReturn { + #[allow(missing_docs)] + pub forwarder: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getTrustedForwarderCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getTrustedForwarderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getTrustedForwarderReturn) -> Self { + (value.forwarder,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getTrustedForwarderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { forwarder: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getTrustedForwarderCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getTrustedForwarder()"; + const SELECTOR: [u8; 4] = [206u8, 27u8, 129u8, 95u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: getTrustedForwarderReturn = r.into(); + r.forwarder + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: getTrustedForwarderReturn = r.into(); + r.forwarder + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `isTrustedForwarder(address)` and selector `0x572b6c05`. +```solidity +function isTrustedForwarder(address forwarder) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isTrustedForwarderCall { + #[allow(missing_docs)] + pub forwarder: alloy::sol_types::private::Address, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`isTrustedForwarder(address)`](isTrustedForwarderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isTrustedForwarderReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isTrustedForwarderCall) -> Self { + (value.forwarder,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isTrustedForwarderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { forwarder: tuple.0 } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isTrustedForwarderReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isTrustedForwarderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isTrustedForwarderCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isTrustedForwarder(address)"; + const SELECTOR: [u8; 4] = [87u8, 43u8, 108u8, 5u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.forwarder, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isTrustedForwarderReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isTrustedForwarderReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `placeBtcBuyOrder(uint256,(bytes),address,uint256)` and selector `0x364f1ec0`. +```solidity +function placeBtcBuyOrder(uint256 amountBtc, BitcoinAddress memory bitcoinAddress, address sellingToken, uint256 saleAmount) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct placeBtcBuyOrderCall { + #[allow(missing_docs)] + pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub bitcoinAddress: ::RustType, + #[allow(missing_docs)] + pub sellingToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub saleAmount: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`placeBtcBuyOrder(uint256,(bytes),address,uint256)`](placeBtcBuyOrderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct placeBtcBuyOrderReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + BitcoinAddress, + 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, + ::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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: placeBtcBuyOrderCall) -> Self { + ( + value.amountBtc, + value.bitcoinAddress, + value.sellingToken, + value.saleAmount, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for placeBtcBuyOrderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + amountBtc: tuple.0, + bitcoinAddress: tuple.1, + sellingToken: tuple.2, + saleAmount: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: placeBtcBuyOrderReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for placeBtcBuyOrderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl placeBtcBuyOrderReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for placeBtcBuyOrderCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + BitcoinAddress, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = placeBtcBuyOrderReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "placeBtcBuyOrder(uint256,(bytes),address,uint256)"; + const SELECTOR: [u8; 4] = [54u8, 79u8, 30u8, 192u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountBtc), + ::tokenize( + &self.bitcoinAddress, + ), + ::tokenize( + &self.sellingToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.saleAmount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + placeBtcBuyOrderReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `placeBtcSellOrder(uint256,address,uint256)` and selector `0x5b8fe042`. +```solidity +function placeBtcSellOrder(uint256 amountBtc, address buyingToken, uint256 buyAmount) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct placeBtcSellOrderCall { + #[allow(missing_docs)] + pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub buyingToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub buyAmount: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`placeBtcSellOrder(uint256,address,uint256)`](placeBtcSellOrderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct placeBtcSellOrderReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + 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::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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: placeBtcSellOrderCall) -> Self { + (value.amountBtc, value.buyingToken, value.buyAmount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for placeBtcSellOrderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + amountBtc: tuple.0, + buyingToken: tuple.1, + buyAmount: tuple.2, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: placeBtcSellOrderReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for placeBtcSellOrderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl placeBtcSellOrderReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for placeBtcSellOrderCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = placeBtcSellOrderReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "placeBtcSellOrder(uint256,address,uint256)"; + const SELECTOR: [u8; 4] = [91u8, 143u8, 224u8, 66u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountBtc), + ::tokenize( + &self.buyingToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.buyAmount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + placeBtcSellOrderReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `proofBtcBuyOrder(uint256,(bytes4,bytes,bytes,bytes4),(bytes,uint256,bytes,bytes32,bytes))` and selector `0xb223d976`. +```solidity +function proofBtcBuyOrder(uint256 id, BitcoinTx.Info memory transaction, BitcoinTx.Proof memory proof) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proofBtcBuyOrderCall { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub transaction: ::RustType, + #[allow(missing_docs)] + pub proof: ::RustType, + } + ///Container type for the return parameters of the [`proofBtcBuyOrder(uint256,(bytes4,bytes,bytes,bytes4),(bytes,uint256,bytes,bytes32,bytes))`](proofBtcBuyOrderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proofBtcBuyOrderReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + BitcoinTx::Info, + BitcoinTx::Proof, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ::RustType, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: proofBtcBuyOrderCall) -> Self { + (value.id, value.transaction, value.proof) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for proofBtcBuyOrderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + id: tuple.0, + transaction: tuple.1, + proof: tuple.2, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: proofBtcBuyOrderReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for proofBtcBuyOrderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl proofBtcBuyOrderReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for proofBtcBuyOrderCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + BitcoinTx::Info, + BitcoinTx::Proof, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = proofBtcBuyOrderReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "proofBtcBuyOrder(uint256,(bytes4,bytes,bytes,bytes4),(bytes,uint256,bytes,bytes32,bytes))"; + const SELECTOR: [u8; 4] = [178u8, 35u8, 217u8, 118u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + ::tokenize( + &self.transaction, + ), + ::tokenize(&self.proof), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + proofBtcBuyOrderReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `proofBtcSellOrder(uint256,(bytes4,bytes,bytes,bytes4),(bytes,uint256,bytes,bytes32,bytes))` and selector `0xfd3fc245`. +```solidity +function proofBtcSellOrder(uint256 id, BitcoinTx.Info memory transaction, BitcoinTx.Proof memory proof) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proofBtcSellOrderCall { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub transaction: ::RustType, + #[allow(missing_docs)] + pub proof: ::RustType, + } + ///Container type for the return parameters of the [`proofBtcSellOrder(uint256,(bytes4,bytes,bytes,bytes4),(bytes,uint256,bytes,bytes32,bytes))`](proofBtcSellOrderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proofBtcSellOrderReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + BitcoinTx::Info, + BitcoinTx::Proof, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ::RustType, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: proofBtcSellOrderCall) -> Self { + (value.id, value.transaction, value.proof) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for proofBtcSellOrderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + id: tuple.0, + transaction: tuple.1, + proof: tuple.2, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: proofBtcSellOrderReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for proofBtcSellOrderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl proofBtcSellOrderReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for proofBtcSellOrderCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + BitcoinTx::Info, + BitcoinTx::Proof, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = proofBtcSellOrderReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "proofBtcSellOrder(uint256,(bytes4,bytes,bytes,bytes4),(bytes,uint256,bytes,bytes32,bytes))"; + const SELECTOR: [u8; 4] = [253u8, 63u8, 194u8, 69u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + ::tokenize( + &self.transaction, + ), + ::tokenize(&self.proof), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + proofBtcSellOrderReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `withdrawBtcBuyOrder(uint256)` and selector `0x506a109d`. +```solidity +function withdrawBtcBuyOrder(uint256 id) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct withdrawBtcBuyOrderCall { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`withdrawBtcBuyOrder(uint256)`](withdrawBtcBuyOrderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct withdrawBtcBuyOrderReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: withdrawBtcBuyOrderCall) -> Self { + (value.id,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for withdrawBtcBuyOrderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { id: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: withdrawBtcBuyOrderReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for withdrawBtcBuyOrderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl withdrawBtcBuyOrderReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for withdrawBtcBuyOrderCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = withdrawBtcBuyOrderReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "withdrawBtcBuyOrder(uint256)"; + const SELECTOR: [u8; 4] = [80u8, 106u8, 16u8, 157u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + withdrawBtcBuyOrderReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `withdrawBtcSellOrder(uint256)` and selector `0xa383013b`. +```solidity +function withdrawBtcSellOrder(uint256 id) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct withdrawBtcSellOrderCall { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`withdrawBtcSellOrder(uint256)`](withdrawBtcSellOrderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct withdrawBtcSellOrderReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: withdrawBtcSellOrderCall) -> Self { + (value.id,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for withdrawBtcSellOrderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { id: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: withdrawBtcSellOrderReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for withdrawBtcSellOrderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl withdrawBtcSellOrderReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for withdrawBtcSellOrderCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = withdrawBtcSellOrderReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "withdrawBtcSellOrder(uint256)"; + const SELECTOR: [u8; 4] = [163u8, 131u8, 1u8, 59u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + withdrawBtcSellOrderReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + ///Container for all the [`BtcMarketPlace`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum BtcMarketPlaceCalls { + #[allow(missing_docs)] + REQUEST_EXPIRATION_SECONDS(REQUEST_EXPIRATION_SECONDSCall), + #[allow(missing_docs)] + acceptBtcBuyOrder(acceptBtcBuyOrderCall), + #[allow(missing_docs)] + acceptBtcSellOrder(acceptBtcSellOrderCall), + #[allow(missing_docs)] + acceptedBtcBuyOrders(acceptedBtcBuyOrdersCall), + #[allow(missing_docs)] + acceptedBtcSellOrders(acceptedBtcSellOrdersCall), + #[allow(missing_docs)] + btcBuyOrders(btcBuyOrdersCall), + #[allow(missing_docs)] + btcSellOrders(btcSellOrdersCall), + #[allow(missing_docs)] + cancelAcceptedBtcBuyOrder(cancelAcceptedBtcBuyOrderCall), + #[allow(missing_docs)] + cancelAcceptedBtcSellOrder(cancelAcceptedBtcSellOrderCall), + #[allow(missing_docs)] + getOpenAcceptedBtcBuyOrders(getOpenAcceptedBtcBuyOrdersCall), + #[allow(missing_docs)] + getOpenAcceptedBtcSellOrders(getOpenAcceptedBtcSellOrdersCall), + #[allow(missing_docs)] + getOpenBtcBuyOrders(getOpenBtcBuyOrdersCall), + #[allow(missing_docs)] + getOpenBtcSellOrders(getOpenBtcSellOrdersCall), + #[allow(missing_docs)] + getTrustedForwarder(getTrustedForwarderCall), + #[allow(missing_docs)] + isTrustedForwarder(isTrustedForwarderCall), + #[allow(missing_docs)] + placeBtcBuyOrder(placeBtcBuyOrderCall), + #[allow(missing_docs)] + placeBtcSellOrder(placeBtcSellOrderCall), + #[allow(missing_docs)] + proofBtcBuyOrder(proofBtcBuyOrderCall), + #[allow(missing_docs)] + proofBtcSellOrder(proofBtcSellOrderCall), + #[allow(missing_docs)] + withdrawBtcBuyOrder(withdrawBtcBuyOrderCall), + #[allow(missing_docs)] + withdrawBtcSellOrder(withdrawBtcSellOrderCall), + } + #[automatically_derived] + impl BtcMarketPlaceCalls { + /// 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]] = &[ + [17u8, 193u8, 55u8, 170u8], + [29u8, 254u8, 117u8, 149u8], + [33u8, 14u8, 193u8, 129u8], + [54u8, 79u8, 30u8, 192u8], + [58u8, 243u8, 252u8, 126u8], + [65u8, 69u8, 100u8, 10u8], + [80u8, 106u8, 16u8, 157u8], + [87u8, 43u8, 108u8, 5u8], + [91u8, 143u8, 224u8, 66u8], + [104u8, 17u8, 163u8, 17u8], + [106u8, 140u8, 222u8, 58u8], + [156u8, 198u8, 114u8, 46u8], + [163u8, 131u8, 1u8, 59u8], + [178u8, 35u8, 217u8, 118u8], + [189u8, 42u8, 126u8, 62u8], + [197u8, 106u8, 69u8, 38u8], + [206u8, 27u8, 129u8, 95u8], + [209u8, 146u8, 15u8, 240u8], + [223u8, 105u8, 177u8, 79u8], + [236u8, 202u8, 44u8, 54u8], + [253u8, 63u8, 194u8, 69u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for BtcMarketPlaceCalls { + const NAME: &'static str = "BtcMarketPlaceCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 21usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::REQUEST_EXPIRATION_SECONDS(_) => { + ::SELECTOR + } + Self::acceptBtcBuyOrder(_) => { + ::SELECTOR + } + Self::acceptBtcSellOrder(_) => { + ::SELECTOR + } + Self::acceptedBtcBuyOrders(_) => { + ::SELECTOR + } + Self::acceptedBtcSellOrders(_) => { + ::SELECTOR + } + Self::btcBuyOrders(_) => { + ::SELECTOR + } + Self::btcSellOrders(_) => { + ::SELECTOR + } + Self::cancelAcceptedBtcBuyOrder(_) => { + ::SELECTOR + } + Self::cancelAcceptedBtcSellOrder(_) => { + ::SELECTOR + } + Self::getOpenAcceptedBtcBuyOrders(_) => { + ::SELECTOR + } + Self::getOpenAcceptedBtcSellOrders(_) => { + ::SELECTOR + } + Self::getOpenBtcBuyOrders(_) => { + ::SELECTOR + } + Self::getOpenBtcSellOrders(_) => { + ::SELECTOR + } + Self::getTrustedForwarder(_) => { + ::SELECTOR + } + Self::isTrustedForwarder(_) => { + ::SELECTOR + } + Self::placeBtcBuyOrder(_) => { + ::SELECTOR + } + Self::placeBtcSellOrder(_) => { + ::SELECTOR + } + Self::proofBtcBuyOrder(_) => { + ::SELECTOR + } + Self::proofBtcSellOrder(_) => { + ::SELECTOR + } + Self::withdrawBtcBuyOrder(_) => { + ::SELECTOR + } + Self::withdrawBtcSellOrder(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn acceptBtcBuyOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BtcMarketPlaceCalls::acceptBtcBuyOrder) + } + acceptBtcBuyOrder + }, + { + fn getOpenBtcBuyOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BtcMarketPlaceCalls::getOpenBtcBuyOrders) + } + getOpenBtcBuyOrders + }, + { + fn acceptBtcSellOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BtcMarketPlaceCalls::acceptBtcSellOrder) + } + acceptBtcSellOrder + }, + { + fn placeBtcBuyOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BtcMarketPlaceCalls::placeBtcBuyOrder) + } + placeBtcBuyOrder + }, + { + fn btcBuyOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BtcMarketPlaceCalls::btcBuyOrders) + } + btcBuyOrders + }, + { + fn acceptedBtcSellOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BtcMarketPlaceCalls::acceptedBtcSellOrders) + } + acceptedBtcSellOrders + }, + { + fn withdrawBtcBuyOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BtcMarketPlaceCalls::withdrawBtcBuyOrder) + } + withdrawBtcBuyOrder + }, + { + fn isTrustedForwarder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BtcMarketPlaceCalls::isTrustedForwarder) + } + isTrustedForwarder + }, + { + fn placeBtcSellOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BtcMarketPlaceCalls::placeBtcSellOrder) + } + placeBtcSellOrder + }, + { + fn getOpenBtcSellOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BtcMarketPlaceCalls::getOpenBtcSellOrders) + } + getOpenBtcSellOrders + }, + { + fn getOpenAcceptedBtcBuyOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BtcMarketPlaceCalls::getOpenAcceptedBtcBuyOrders) + } + getOpenAcceptedBtcBuyOrders + }, + { + fn getOpenAcceptedBtcSellOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BtcMarketPlaceCalls::getOpenAcceptedBtcSellOrders) + } + getOpenAcceptedBtcSellOrders + }, + { + fn withdrawBtcSellOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BtcMarketPlaceCalls::withdrawBtcSellOrder) + } + withdrawBtcSellOrder + }, + { + fn proofBtcBuyOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BtcMarketPlaceCalls::proofBtcBuyOrder) + } + proofBtcBuyOrder + }, + { + fn acceptedBtcBuyOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BtcMarketPlaceCalls::acceptedBtcBuyOrders) + } + acceptedBtcBuyOrders + }, + { + fn cancelAcceptedBtcBuyOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BtcMarketPlaceCalls::cancelAcceptedBtcBuyOrder) + } + cancelAcceptedBtcBuyOrder + }, + { + fn getTrustedForwarder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BtcMarketPlaceCalls::getTrustedForwarder) + } + getTrustedForwarder + }, + { + fn REQUEST_EXPIRATION_SECONDS( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BtcMarketPlaceCalls::REQUEST_EXPIRATION_SECONDS) + } + REQUEST_EXPIRATION_SECONDS + }, + { + fn cancelAcceptedBtcSellOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BtcMarketPlaceCalls::cancelAcceptedBtcSellOrder) + } + cancelAcceptedBtcSellOrder + }, + { + fn btcSellOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BtcMarketPlaceCalls::btcSellOrders) + } + btcSellOrders + }, + { + fn proofBtcSellOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BtcMarketPlaceCalls::proofBtcSellOrder) + } + proofBtcSellOrder + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn acceptBtcBuyOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BtcMarketPlaceCalls::acceptBtcBuyOrder) + } + acceptBtcBuyOrder + }, + { + fn getOpenBtcBuyOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BtcMarketPlaceCalls::getOpenBtcBuyOrders) + } + getOpenBtcBuyOrders + }, + { + fn acceptBtcSellOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BtcMarketPlaceCalls::acceptBtcSellOrder) + } + acceptBtcSellOrder + }, + { + fn placeBtcBuyOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BtcMarketPlaceCalls::placeBtcBuyOrder) + } + placeBtcBuyOrder + }, + { + fn btcBuyOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BtcMarketPlaceCalls::btcBuyOrders) + } + btcBuyOrders + }, + { + fn acceptedBtcSellOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BtcMarketPlaceCalls::acceptedBtcSellOrders) + } + acceptedBtcSellOrders + }, + { + fn withdrawBtcBuyOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BtcMarketPlaceCalls::withdrawBtcBuyOrder) + } + withdrawBtcBuyOrder + }, + { + fn isTrustedForwarder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BtcMarketPlaceCalls::isTrustedForwarder) + } + isTrustedForwarder + }, + { + fn placeBtcSellOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BtcMarketPlaceCalls::placeBtcSellOrder) + } + placeBtcSellOrder + }, + { + fn getOpenBtcSellOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BtcMarketPlaceCalls::getOpenBtcSellOrders) + } + getOpenBtcSellOrders + }, + { + fn getOpenAcceptedBtcBuyOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BtcMarketPlaceCalls::getOpenAcceptedBtcBuyOrders) + } + getOpenAcceptedBtcBuyOrders + }, + { + fn getOpenAcceptedBtcSellOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BtcMarketPlaceCalls::getOpenAcceptedBtcSellOrders) + } + getOpenAcceptedBtcSellOrders + }, + { + fn withdrawBtcSellOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BtcMarketPlaceCalls::withdrawBtcSellOrder) + } + withdrawBtcSellOrder + }, + { + fn proofBtcBuyOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BtcMarketPlaceCalls::proofBtcBuyOrder) + } + proofBtcBuyOrder + }, + { + fn acceptedBtcBuyOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BtcMarketPlaceCalls::acceptedBtcBuyOrders) + } + acceptedBtcBuyOrders + }, + { + fn cancelAcceptedBtcBuyOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BtcMarketPlaceCalls::cancelAcceptedBtcBuyOrder) + } + cancelAcceptedBtcBuyOrder + }, + { + fn getTrustedForwarder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BtcMarketPlaceCalls::getTrustedForwarder) + } + getTrustedForwarder + }, + { + fn REQUEST_EXPIRATION_SECONDS( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BtcMarketPlaceCalls::REQUEST_EXPIRATION_SECONDS) + } + REQUEST_EXPIRATION_SECONDS + }, + { + fn cancelAcceptedBtcSellOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BtcMarketPlaceCalls::cancelAcceptedBtcSellOrder) + } + cancelAcceptedBtcSellOrder + }, + { + fn btcSellOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BtcMarketPlaceCalls::btcSellOrders) + } + btcSellOrders + }, + { + fn proofBtcSellOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BtcMarketPlaceCalls::proofBtcSellOrder) + } + proofBtcSellOrder + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::REQUEST_EXPIRATION_SECONDS(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::acceptBtcBuyOrder(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::acceptBtcSellOrder(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::acceptedBtcBuyOrders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::acceptedBtcSellOrders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::btcBuyOrders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::btcSellOrders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::cancelAcceptedBtcBuyOrder(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::cancelAcceptedBtcSellOrder(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getOpenAcceptedBtcBuyOrders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getOpenAcceptedBtcSellOrders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getOpenBtcBuyOrders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getOpenBtcSellOrders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getTrustedForwarder(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::isTrustedForwarder(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::placeBtcBuyOrder(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::placeBtcSellOrder(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::proofBtcBuyOrder(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::proofBtcSellOrder(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::withdrawBtcBuyOrder(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::withdrawBtcSellOrder(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::REQUEST_EXPIRATION_SECONDS(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::acceptBtcBuyOrder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::acceptBtcSellOrder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::acceptedBtcBuyOrders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::acceptedBtcSellOrders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::btcBuyOrders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::btcSellOrders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::cancelAcceptedBtcBuyOrder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::cancelAcceptedBtcSellOrder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getOpenAcceptedBtcBuyOrders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getOpenAcceptedBtcSellOrders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getOpenBtcBuyOrders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getOpenBtcSellOrders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getTrustedForwarder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isTrustedForwarder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::placeBtcBuyOrder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::placeBtcSellOrder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::proofBtcBuyOrder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::proofBtcSellOrder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::withdrawBtcBuyOrder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::withdrawBtcSellOrder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`BtcMarketPlace`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum BtcMarketPlaceEvents { + #[allow(missing_docs)] + acceptBtcBuyOrderEvent(acceptBtcBuyOrderEvent), + #[allow(missing_docs)] + acceptBtcSellOrderEvent(acceptBtcSellOrderEvent), + #[allow(missing_docs)] + cancelAcceptedBtcBuyOrderEvent(cancelAcceptedBtcBuyOrderEvent), + #[allow(missing_docs)] + cancelAcceptedBtcSellOrderEvent(cancelAcceptedBtcSellOrderEvent), + #[allow(missing_docs)] + placeBtcBuyOrderEvent(placeBtcBuyOrderEvent), + #[allow(missing_docs)] + placeBtcSellOrderEvent(placeBtcSellOrderEvent), + #[allow(missing_docs)] + proofBtcBuyOrderEvent(proofBtcBuyOrderEvent), + #[allow(missing_docs)] + proofBtcSellOrderEvent(proofBtcSellOrderEvent), + #[allow(missing_docs)] + withdrawBtcBuyOrderEvent(withdrawBtcBuyOrderEvent), + #[allow(missing_docs)] + withdrawBtcSellOrderEvent(withdrawBtcSellOrderEvent), + } + #[automatically_derived] + impl BtcMarketPlaceEvents { + /// 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]] = &[ + [ + 60u8, 212u8, 117u8, 176u8, 146u8, 232u8, 179u8, 121u8, 246u8, 186u8, + 13u8, 158u8, 14u8, 12u8, 143u8, 48u8, 112u8, 94u8, 115u8, 50u8, 29u8, + 197u8, 201u8, 248u8, 12u8, 228u8, 173u8, 56u8, 219u8, 123u8, 225u8, 170u8, + ], + [ + 62u8, 94u8, 163u8, 88u8, 233u8, 235u8, 76u8, 223u8, 68u8, 205u8, 199u8, + 121u8, 56u8, 173u8, 232u8, 7u8, 75u8, 18u8, 64u8, 166u8, 216u8, 192u8, + 253u8, 19u8, 114u8, 134u8, 113u8, 184u8, 46u8, 128u8, 10u8, 214u8, + ], + [ + 101u8, 62u8, 13u8, 129u8, 242u8, 201u8, 155u8, 235u8, 163u8, 89u8, 223u8, + 177u8, 123u8, 73u8, 154u8, 92u8, 255u8, 43u8, 233u8, 217u8, 80u8, 81u8, + 72u8, 82u8, 34u8, 77u8, 248u8, 192u8, 151u8, 194u8, 25u8, 33u8, + ], + [ + 120u8, 245u8, 31u8, 98u8, 247u8, 207u8, 19u8, 129u8, 198u8, 115u8, 194u8, + 126u8, 174u8, 24u8, 125u8, 214u8, 197u8, 136u8, 220u8, 102u8, 36u8, + 206u8, 89u8, 105u8, 125u8, 187u8, 62u8, 29u8, 124u8, 27u8, 188u8, 223u8, + ], + [ + 152u8, 199u8, 198u8, 128u8, 64u8, 61u8, 71u8, 64u8, 61u8, 234u8, 74u8, + 87u8, 13u8, 14u8, 108u8, 87u8, 22u8, 83u8, 140u8, 73u8, 66u8, 14u8, + 244u8, 113u8, 206u8, 196u8, 40u8, 245u8, 165u8, 133u8, 44u8, 6u8, + ], + [ + 180u8, 201u8, 141u8, 226u8, 16u8, 105u8, 107u8, 60u8, 242u8, 30u8, 153u8, + 51u8, 92u8, 30u8, 227u8, 160u8, 174u8, 52u8, 162u8, 103u8, 19u8, 65u8, + 42u8, 74u8, 221u8, 232u8, 175u8, 89u8, 97u8, 118u8, 243u8, 126u8, + ], + [ + 195u8, 64u8, 231u8, 172u8, 72u8, 220u8, 128u8, 238u8, 121u8, 63u8, 198u8, + 38u8, 105u8, 96u8, 189u8, 95u8, 27u8, 210u8, 27u8, 233u8, 28u8, 138u8, + 149u8, 226u8, 24u8, 23u8, 129u8, 19u8, 247u8, 158u8, 23u8, 180u8, + ], + [ + 195u8, 154u8, 26u8, 93u8, 220u8, 14u8, 133u8, 201u8, 85u8, 254u8, 46u8, + 26u8, 190u8, 180u8, 60u8, 148u8, 206u8, 24u8, 50u8, 46u8, 117u8, 187u8, + 61u8, 68u8, 232u8, 15u8, 117u8, 159u8, 249u8, 208u8, 52u8, 185u8, + ], + [ + 207u8, 86u8, 16u8, 97u8, 219u8, 120u8, 247u8, 188u8, 81u8, 141u8, 55u8, + 254u8, 134u8, 113u8, 133u8, 20u8, 198u8, 64u8, 204u8, 197u8, 195u8, + 241u8, 41u8, 56u8, 40u8, 185u8, 85u8, 230u8, 143u8, 25u8, 245u8, 251u8, + ], + [ + 255u8, 28u8, 226u8, 16u8, 222u8, 252u8, 211u8, 186u8, 26u8, 223u8, 118u8, + 201u8, 65u8, 154u8, 7u8, 88u8, 250u8, 96u8, 253u8, 62u8, 179u8, 140u8, + 123u8, 217u8, 65u8, 143u8, 96u8, 181u8, 117u8, 183u8, 110u8, 36u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for BtcMarketPlaceEvents { + const NAME: &'static str = "BtcMarketPlaceEvents"; + const COUNT: usize = 10usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::acceptBtcBuyOrderEvent) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::acceptBtcSellOrderEvent) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::cancelAcceptedBtcBuyOrderEvent) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::cancelAcceptedBtcSellOrderEvent) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::placeBtcBuyOrderEvent) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::placeBtcSellOrderEvent) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::proofBtcBuyOrderEvent) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::proofBtcSellOrderEvent) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::withdrawBtcBuyOrderEvent) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::withdrawBtcSellOrderEvent) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 BtcMarketPlaceEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::acceptBtcBuyOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::acceptBtcSellOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::cancelAcceptedBtcBuyOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::cancelAcceptedBtcSellOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::placeBtcBuyOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::placeBtcSellOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::proofBtcBuyOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::proofBtcSellOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::withdrawBtcBuyOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::withdrawBtcSellOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::acceptBtcBuyOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::acceptBtcSellOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::cancelAcceptedBtcBuyOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::cancelAcceptedBtcSellOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::placeBtcBuyOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::placeBtcSellOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::proofBtcBuyOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::proofBtcSellOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::withdrawBtcBuyOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::withdrawBtcSellOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`BtcMarketPlace`](self) contract instance. + +See the [wrapper's documentation](`BtcMarketPlaceInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> BtcMarketPlaceInstance { + BtcMarketPlaceInstance::::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: alloy_contract::private::Network, + >( + provider: P, + _relay: alloy::sol_types::private::Address, + erc2771Forwarder: alloy::sol_types::private::Address, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + BtcMarketPlaceInstance::::deploy(provider, _relay, erc2771Forwarder) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + _relay: alloy::sol_types::private::Address, + erc2771Forwarder: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + BtcMarketPlaceInstance::< + P, + N, + >::deploy_builder(provider, _relay, erc2771Forwarder) + } + /**A [`BtcMarketPlace`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`BtcMarketPlace`](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 BtcMarketPlaceInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for BtcMarketPlaceInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("BtcMarketPlaceInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BtcMarketPlaceInstance { + /**Creates a new wrapper around an on-chain [`BtcMarketPlace`](self) contract instance. + +See the [wrapper's documentation](`BtcMarketPlaceInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + _relay: alloy::sol_types::private::Address, + erc2771Forwarder: alloy::sol_types::private::Address, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(provider, _relay, erc2771Forwarder); + 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, + _relay: alloy::sol_types::private::Address, + erc2771Forwarder: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + _relay, + erc2771Forwarder, + }, + )[..], + ] + .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 BtcMarketPlaceInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> BtcMarketPlaceInstance { + BtcMarketPlaceInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BtcMarketPlaceInstance { + /// 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( + &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 [`REQUEST_EXPIRATION_SECONDS`] function. + pub fn REQUEST_EXPIRATION_SECONDS( + &self, + ) -> alloy_contract::SolCallBuilder<&P, REQUEST_EXPIRATION_SECONDSCall, N> { + self.call_builder(&REQUEST_EXPIRATION_SECONDSCall) + } + ///Creates a new call builder for the [`acceptBtcBuyOrder`] function. + pub fn acceptBtcBuyOrder( + &self, + id: alloy::sol_types::private::primitives::aliases::U256, + amountBtc: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, acceptBtcBuyOrderCall, N> { + self.call_builder( + &acceptBtcBuyOrderCall { + id, + amountBtc, + }, + ) + } + ///Creates a new call builder for the [`acceptBtcSellOrder`] function. + pub fn acceptBtcSellOrder( + &self, + id: alloy::sol_types::private::primitives::aliases::U256, + bitcoinAddress: ::RustType, + amountBtc: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, acceptBtcSellOrderCall, N> { + self.call_builder( + &acceptBtcSellOrderCall { + id, + bitcoinAddress, + amountBtc, + }, + ) + } + ///Creates a new call builder for the [`acceptedBtcBuyOrders`] function. + pub fn acceptedBtcBuyOrders( + &self, + _0: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, acceptedBtcBuyOrdersCall, N> { + self.call_builder(&acceptedBtcBuyOrdersCall(_0)) + } + ///Creates a new call builder for the [`acceptedBtcSellOrders`] function. + pub fn acceptedBtcSellOrders( + &self, + _0: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, acceptedBtcSellOrdersCall, N> { + self.call_builder(&acceptedBtcSellOrdersCall(_0)) + } + ///Creates a new call builder for the [`btcBuyOrders`] function. + pub fn btcBuyOrders( + &self, + _0: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, btcBuyOrdersCall, N> { + self.call_builder(&btcBuyOrdersCall(_0)) + } + ///Creates a new call builder for the [`btcSellOrders`] function. + pub fn btcSellOrders( + &self, + _0: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, btcSellOrdersCall, N> { + self.call_builder(&btcSellOrdersCall(_0)) + } + ///Creates a new call builder for the [`cancelAcceptedBtcBuyOrder`] function. + pub fn cancelAcceptedBtcBuyOrder( + &self, + id: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, cancelAcceptedBtcBuyOrderCall, N> { + self.call_builder( + &cancelAcceptedBtcBuyOrderCall { + id, + }, + ) + } + ///Creates a new call builder for the [`cancelAcceptedBtcSellOrder`] function. + pub fn cancelAcceptedBtcSellOrder( + &self, + id: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, cancelAcceptedBtcSellOrderCall, N> { + self.call_builder( + &cancelAcceptedBtcSellOrderCall { + id, + }, + ) + } + ///Creates a new call builder for the [`getOpenAcceptedBtcBuyOrders`] function. + pub fn getOpenAcceptedBtcBuyOrders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, getOpenAcceptedBtcBuyOrdersCall, N> { + self.call_builder(&getOpenAcceptedBtcBuyOrdersCall) + } + ///Creates a new call builder for the [`getOpenAcceptedBtcSellOrders`] function. + pub fn getOpenAcceptedBtcSellOrders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, getOpenAcceptedBtcSellOrdersCall, N> { + self.call_builder(&getOpenAcceptedBtcSellOrdersCall) + } + ///Creates a new call builder for the [`getOpenBtcBuyOrders`] function. + pub fn getOpenBtcBuyOrders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, getOpenBtcBuyOrdersCall, N> { + self.call_builder(&getOpenBtcBuyOrdersCall) + } + ///Creates a new call builder for the [`getOpenBtcSellOrders`] function. + pub fn getOpenBtcSellOrders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, getOpenBtcSellOrdersCall, N> { + self.call_builder(&getOpenBtcSellOrdersCall) + } + ///Creates a new call builder for the [`getTrustedForwarder`] function. + pub fn getTrustedForwarder( + &self, + ) -> alloy_contract::SolCallBuilder<&P, getTrustedForwarderCall, N> { + self.call_builder(&getTrustedForwarderCall) + } + ///Creates a new call builder for the [`isTrustedForwarder`] function. + pub fn isTrustedForwarder( + &self, + forwarder: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isTrustedForwarderCall, N> { + self.call_builder( + &isTrustedForwarderCall { + forwarder, + }, + ) + } + ///Creates a new call builder for the [`placeBtcBuyOrder`] function. + pub fn placeBtcBuyOrder( + &self, + amountBtc: alloy::sol_types::private::primitives::aliases::U256, + bitcoinAddress: ::RustType, + sellingToken: alloy::sol_types::private::Address, + saleAmount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, placeBtcBuyOrderCall, N> { + self.call_builder( + &placeBtcBuyOrderCall { + amountBtc, + bitcoinAddress, + sellingToken, + saleAmount, + }, + ) + } + ///Creates a new call builder for the [`placeBtcSellOrder`] function. + pub fn placeBtcSellOrder( + &self, + amountBtc: alloy::sol_types::private::primitives::aliases::U256, + buyingToken: alloy::sol_types::private::Address, + buyAmount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, placeBtcSellOrderCall, N> { + self.call_builder( + &placeBtcSellOrderCall { + amountBtc, + buyingToken, + buyAmount, + }, + ) + } + ///Creates a new call builder for the [`proofBtcBuyOrder`] function. + pub fn proofBtcBuyOrder( + &self, + id: alloy::sol_types::private::primitives::aliases::U256, + transaction: ::RustType, + proof: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, proofBtcBuyOrderCall, N> { + self.call_builder( + &proofBtcBuyOrderCall { + id, + transaction, + proof, + }, + ) + } + ///Creates a new call builder for the [`proofBtcSellOrder`] function. + pub fn proofBtcSellOrder( + &self, + id: alloy::sol_types::private::primitives::aliases::U256, + transaction: ::RustType, + proof: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, proofBtcSellOrderCall, N> { + self.call_builder( + &proofBtcSellOrderCall { + id, + transaction, + proof, + }, + ) + } + ///Creates a new call builder for the [`withdrawBtcBuyOrder`] function. + pub fn withdrawBtcBuyOrder( + &self, + id: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, withdrawBtcBuyOrderCall, N> { + self.call_builder(&withdrawBtcBuyOrderCall { id }) + } + ///Creates a new call builder for the [`withdrawBtcSellOrder`] function. + pub fn withdrawBtcSellOrder( + &self, + id: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, withdrawBtcSellOrderCall, N> { + self.call_builder(&withdrawBtcSellOrderCall { id }) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BtcMarketPlaceInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`acceptBtcBuyOrderEvent`] event. + pub fn acceptBtcBuyOrderEvent_filter( + &self, + ) -> alloy_contract::Event<&P, acceptBtcBuyOrderEvent, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`acceptBtcSellOrderEvent`] event. + pub fn acceptBtcSellOrderEvent_filter( + &self, + ) -> alloy_contract::Event<&P, acceptBtcSellOrderEvent, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`cancelAcceptedBtcBuyOrderEvent`] event. + pub fn cancelAcceptedBtcBuyOrderEvent_filter( + &self, + ) -> alloy_contract::Event<&P, cancelAcceptedBtcBuyOrderEvent, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`cancelAcceptedBtcSellOrderEvent`] event. + pub fn cancelAcceptedBtcSellOrderEvent_filter( + &self, + ) -> alloy_contract::Event<&P, cancelAcceptedBtcSellOrderEvent, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`placeBtcBuyOrderEvent`] event. + pub fn placeBtcBuyOrderEvent_filter( + &self, + ) -> alloy_contract::Event<&P, placeBtcBuyOrderEvent, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`placeBtcSellOrderEvent`] event. + pub fn placeBtcSellOrderEvent_filter( + &self, + ) -> alloy_contract::Event<&P, placeBtcSellOrderEvent, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`proofBtcBuyOrderEvent`] event. + pub fn proofBtcBuyOrderEvent_filter( + &self, + ) -> alloy_contract::Event<&P, proofBtcBuyOrderEvent, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`proofBtcSellOrderEvent`] event. + pub fn proofBtcSellOrderEvent_filter( + &self, + ) -> alloy_contract::Event<&P, proofBtcSellOrderEvent, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`withdrawBtcBuyOrderEvent`] event. + pub fn withdrawBtcBuyOrderEvent_filter( + &self, + ) -> alloy_contract::Event<&P, withdrawBtcBuyOrderEvent, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`withdrawBtcSellOrderEvent`] event. + pub fn withdrawBtcSellOrderEvent_filter( + &self, + ) -> alloy_contract::Event<&P, withdrawBtcSellOrderEvent, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/btc_utils.rs b/crates/bindings/src/btc_utils.rs new file mode 100644 index 000000000..58c2c2447 --- /dev/null +++ b/crates/bindings/src/btc_utils.rs @@ -0,0 +1,1127 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface BTCUtils { + function DIFF1_TARGET() external view returns (uint256); + function ERR_BAD_ARG() external view returns (uint256); + function RETARGET_PERIOD() external view returns (uint256); + function RETARGET_PERIOD_BLOCKS() external view returns (uint256); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "DIFF1_TARGET", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "ERR_BAD_ARG", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "RETARGET_PERIOD", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "RETARGET_PERIOD_BLOCKS", + "inputs": [], + "outputs": [ + { + "name": "", + "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 BTCUtils { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x60f5610033600b8282823980515f1a607314602757634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106050575f3560e01c8063056e04ec1460545780638cc7156914606f5780638db69e60146077578063d4258ca714609d575b5f5ffd5b605d6212750081565b60405190815260200160405180910390f35b605d6107e081565b605d7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff81565b605d7bffff00000000000000000000000000000000000000000000000000008156fea26469706673582212204afe711b3e801231c37f83227290cabaa52e9f6dd8632511d4665f0d533ba5d964736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\xF5a\x003`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`'WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R`\x046\x10`PW_5`\xE0\x1C\x80c\x05n\x04\xEC\x14`TW\x80c\x8C\xC7\x15i\x14`oW\x80c\x8D\xB6\x9E`\x14`wW\x80c\xD4%\x8C\xA7\x14`\x9DW[__\xFD[`]b\x12u\0\x81V[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[`]a\x07\xE0\x81V[`]\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81V[`]{\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\x81V\xFE\xA2dipfsX\"\x12 J\xFEq\x1B>\x80\x121\xC3\x7F\x83\"r\x90\xCA\xBA\xA5.\x9Fm\xD8c%\x11\xD4f_\rS;\xA5\xD9dsolcC\0\x08\x1C\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x73000000000000000000000000000000000000000030146080604052600436106050575f3560e01c8063056e04ec1460545780638cc7156914606f5780638db69e60146077578063d4258ca714609d575b5f5ffd5b605d6212750081565b60405190815260200160405180910390f35b605d6107e081565b605d7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff81565b605d7bffff00000000000000000000000000000000000000000000000000008156fea26469706673582212204afe711b3e801231c37f83227290cabaa52e9f6dd8632511d4665f0d533ba5d964736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R`\x046\x10`PW_5`\xE0\x1C\x80c\x05n\x04\xEC\x14`TW\x80c\x8C\xC7\x15i\x14`oW\x80c\x8D\xB6\x9E`\x14`wW\x80c\xD4%\x8C\xA7\x14`\x9DW[__\xFD[`]b\x12u\0\x81V[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[`]a\x07\xE0\x81V[`]\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81V[`]{\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\x81V\xFE\xA2dipfsX\"\x12 J\xFEq\x1B>\x80\x121\xC3\x7F\x83\"r\x90\xCA\xBA\xA5.\x9Fm\xD8c%\x11\xD4f_\rS;\xA5\xD9dsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `DIFF1_TARGET()` and selector `0xd4258ca7`. +```solidity +function DIFF1_TARGET() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct DIFF1_TARGETCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`DIFF1_TARGET()`](DIFF1_TARGETCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct DIFF1_TARGETReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: DIFF1_TARGETCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for DIFF1_TARGETCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: DIFF1_TARGETReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for DIFF1_TARGETReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for DIFF1_TARGETCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "DIFF1_TARGET()"; + const SELECTOR: [u8; 4] = [212u8, 37u8, 140u8, 167u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: DIFF1_TARGETReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: DIFF1_TARGETReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `ERR_BAD_ARG()` and selector `0x8db69e60`. +```solidity +function ERR_BAD_ARG() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ERR_BAD_ARGCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`ERR_BAD_ARG()`](ERR_BAD_ARGCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ERR_BAD_ARGReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ERR_BAD_ARGCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ERR_BAD_ARGCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ERR_BAD_ARGReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ERR_BAD_ARGReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for ERR_BAD_ARGCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ERR_BAD_ARG()"; + const SELECTOR: [u8; 4] = [141u8, 182u8, 158u8, 96u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: ERR_BAD_ARGReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: ERR_BAD_ARGReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `RETARGET_PERIOD()` and selector `0x056e04ec`. +```solidity +function RETARGET_PERIOD() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct RETARGET_PERIODCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`RETARGET_PERIOD()`](RETARGET_PERIODCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct RETARGET_PERIODReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: RETARGET_PERIODCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for RETARGET_PERIODCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: RETARGET_PERIODReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for RETARGET_PERIODReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for RETARGET_PERIODCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "RETARGET_PERIOD()"; + const SELECTOR: [u8; 4] = [5u8, 110u8, 4u8, 236u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: RETARGET_PERIODReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: RETARGET_PERIODReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `RETARGET_PERIOD_BLOCKS()` and selector `0x8cc71569`. +```solidity +function RETARGET_PERIOD_BLOCKS() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct RETARGET_PERIOD_BLOCKSCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`RETARGET_PERIOD_BLOCKS()`](RETARGET_PERIOD_BLOCKSCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct RETARGET_PERIOD_BLOCKSReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: RETARGET_PERIOD_BLOCKSCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for RETARGET_PERIOD_BLOCKSCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: RETARGET_PERIOD_BLOCKSReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for RETARGET_PERIOD_BLOCKSReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for RETARGET_PERIOD_BLOCKSCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "RETARGET_PERIOD_BLOCKS()"; + const SELECTOR: [u8; 4] = [140u8, 199u8, 21u8, 105u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: RETARGET_PERIOD_BLOCKSReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: RETARGET_PERIOD_BLOCKSReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`BTCUtils`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum BTCUtilsCalls { + #[allow(missing_docs)] + DIFF1_TARGET(DIFF1_TARGETCall), + #[allow(missing_docs)] + ERR_BAD_ARG(ERR_BAD_ARGCall), + #[allow(missing_docs)] + RETARGET_PERIOD(RETARGET_PERIODCall), + #[allow(missing_docs)] + RETARGET_PERIOD_BLOCKS(RETARGET_PERIOD_BLOCKSCall), + } + #[automatically_derived] + impl BTCUtilsCalls { + /// 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, 110u8, 4u8, 236u8], + [140u8, 199u8, 21u8, 105u8], + [141u8, 182u8, 158u8, 96u8], + [212u8, 37u8, 140u8, 167u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for BTCUtilsCalls { + const NAME: &'static str = "BTCUtilsCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 4usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::DIFF1_TARGET(_) => { + ::SELECTOR + } + Self::ERR_BAD_ARG(_) => { + ::SELECTOR + } + Self::RETARGET_PERIOD(_) => { + ::SELECTOR + } + Self::RETARGET_PERIOD_BLOCKS(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn RETARGET_PERIOD( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BTCUtilsCalls::RETARGET_PERIOD) + } + RETARGET_PERIOD + }, + { + fn RETARGET_PERIOD_BLOCKS( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BTCUtilsCalls::RETARGET_PERIOD_BLOCKS) + } + RETARGET_PERIOD_BLOCKS + }, + { + fn ERR_BAD_ARG( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BTCUtilsCalls::ERR_BAD_ARG) + } + ERR_BAD_ARG + }, + { + fn DIFF1_TARGET( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(BTCUtilsCalls::DIFF1_TARGET) + } + DIFF1_TARGET + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn RETARGET_PERIOD( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BTCUtilsCalls::RETARGET_PERIOD) + } + RETARGET_PERIOD + }, + { + fn RETARGET_PERIOD_BLOCKS( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BTCUtilsCalls::RETARGET_PERIOD_BLOCKS) + } + RETARGET_PERIOD_BLOCKS + }, + { + fn ERR_BAD_ARG( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BTCUtilsCalls::ERR_BAD_ARG) + } + ERR_BAD_ARG + }, + { + fn DIFF1_TARGET( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(BTCUtilsCalls::DIFF1_TARGET) + } + DIFF1_TARGET + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::DIFF1_TARGET(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ERR_BAD_ARG(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::RETARGET_PERIOD(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::RETARGET_PERIOD_BLOCKS(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::DIFF1_TARGET(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ERR_BAD_ARG(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::RETARGET_PERIOD(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::RETARGET_PERIOD_BLOCKS(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`BTCUtils`](self) contract instance. + +See the [wrapper's documentation](`BTCUtilsInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> BTCUtilsInstance { + BTCUtilsInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + BTCUtilsInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + BTCUtilsInstance::::deploy_builder(provider) + } + /**A [`BTCUtils`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`BTCUtils`](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 BTCUtilsInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for BTCUtilsInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("BTCUtilsInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BTCUtilsInstance { + /**Creates a new wrapper around an on-chain [`BTCUtils`](self) contract instance. + +See the [wrapper's documentation](`BTCUtilsInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 BTCUtilsInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> BTCUtilsInstance { + BTCUtilsInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BTCUtilsInstance { + /// 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( + &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 [`DIFF1_TARGET`] function. + pub fn DIFF1_TARGET( + &self, + ) -> alloy_contract::SolCallBuilder<&P, DIFF1_TARGETCall, N> { + self.call_builder(&DIFF1_TARGETCall) + } + ///Creates a new call builder for the [`ERR_BAD_ARG`] function. + pub fn ERR_BAD_ARG( + &self, + ) -> alloy_contract::SolCallBuilder<&P, ERR_BAD_ARGCall, N> { + self.call_builder(&ERR_BAD_ARGCall) + } + ///Creates a new call builder for the [`RETARGET_PERIOD`] function. + pub fn RETARGET_PERIOD( + &self, + ) -> alloy_contract::SolCallBuilder<&P, RETARGET_PERIODCall, N> { + self.call_builder(&RETARGET_PERIODCall) + } + ///Creates a new call builder for the [`RETARGET_PERIOD_BLOCKS`] function. + pub fn RETARGET_PERIOD_BLOCKS( + &self, + ) -> alloy_contract::SolCallBuilder<&P, RETARGET_PERIOD_BLOCKSCall, N> { + self.call_builder(&RETARGET_PERIOD_BLOCKSCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BTCUtilsInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/bytes_lib.rs b/crates/bindings/src/bytes_lib.rs new file mode 100644 index 000000000..c19571143 --- /dev/null +++ b/crates/bindings/src/bytes_lib.rs @@ -0,0 +1,218 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface BytesLib {} +``` + +...which was generated by the following JSON ABI: +```json +[] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod BytesLib { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212209a4a0cd11b50491dcbc1b2a3e1999d38d54febad1422a52d9aadf9a58b393f7764736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`U`2`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`&WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \x9AJ\x0C\xD1\x1BPI\x1D\xCB\xC1\xB2\xA3\xE1\x99\x9D8\xD5O\xEB\xAD\x14\"\xA5-\x9A\xAD\xF9\xA5\x8B9?wdsolcC\0\x08\x1C\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212209a4a0cd11b50491dcbc1b2a3e1999d38d54febad1422a52d9aadf9a58b393f7764736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \x9AJ\x0C\xD1\x1BPI\x1D\xCB\xC1\xB2\xA3\xE1\x99\x9D8\xD5O\xEB\xAD\x14\"\xA5-\x9A\xAD\xF9\xA5\x8B9?wdsolcC\0\x08\x1C\x003", + ); + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`BytesLib`](self) contract instance. + +See the [wrapper's documentation](`BytesLibInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> BytesLibInstance { + BytesLibInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + BytesLibInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + BytesLibInstance::::deploy_builder(provider) + } + /**A [`BytesLib`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`BytesLib`](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 BytesLibInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for BytesLibInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("BytesLibInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BytesLibInstance { + /**Creates a new wrapper around an on-chain [`BytesLib`](self) contract instance. + +See the [wrapper's documentation](`BytesLibInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 BytesLibInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> BytesLibInstance { + BytesLibInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BytesLibInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BytesLibInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/constants.rs b/crates/bindings/src/constants.rs new file mode 100644 index 000000000..38e7eadfb --- /dev/null +++ b/crates/bindings/src/constants.rs @@ -0,0 +1,218 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface Constants {} +``` + +...which was generated by the following JSON ABI: +```json +[] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod Constants { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220b69d9c4cc91b81f95f9c689cc275984dcc763f96c9734bc4af4883ea2035ca5464736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`U`2`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`&WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \xB6\x9D\x9CL\xC9\x1B\x81\xF9_\x9Ch\x9C\xC2u\x98M\xCCv?\x96\xC9sK\xC4\xAFH\x83\xEA 5\xCATdsolcC\0\x08\x1C\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220b69d9c4cc91b81f95f9c689cc275984dcc763f96c9734bc4af4883ea2035ca5464736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \xB6\x9D\x9CL\xC9\x1B\x81\xF9_\x9Ch\x9C\xC2u\x98M\xCCv?\x96\xC9sK\xC4\xAFH\x83\xEA 5\xCATdsolcC\0\x08\x1C\x003", + ); + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`Constants`](self) contract instance. + +See the [wrapper's documentation](`ConstantsInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> ConstantsInstance { + ConstantsInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + ConstantsInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + ConstantsInstance::::deploy_builder(provider) + } + /**A [`Constants`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`Constants`](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 ConstantsInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for ConstantsInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("ConstantsInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ConstantsInstance { + /**Creates a new wrapper around an on-chain [`Constants`](self) contract instance. + +See the [wrapper's documentation](`ConstantsInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 ConstantsInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> ConstantsInstance { + ConstantsInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ConstantsInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ConstantsInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/context.rs b/crates/bindings/src/context.rs new file mode 100644 index 000000000..093632258 --- /dev/null +++ b/crates/bindings/src/context.rs @@ -0,0 +1,215 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface Context {} +``` + +...which was generated by the following JSON ABI: +```json +[] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod Context { + use super::*; + use alloy::sol_types as 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"", + ); + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`Context`](self) contract instance. + +See the [wrapper's documentation](`ContextInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >(address: alloy_sol_types::private::Address, provider: P) -> ContextInstance { + ContextInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + ContextInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + ContextInstance::::deploy_builder(provider) + } + /**A [`Context`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`Context`](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 ContextInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for ContextInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("ContextInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ContextInstance { + /**Creates a new wrapper around an on-chain [`Context`](self) contract instance. + +See the [wrapper's documentation](`ContextInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 ContextInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> ContextInstance { + ContextInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ContextInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ContextInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/dummy_avalon_pool_implementation.rs b/crates/bindings/src/dummy_avalon_pool_implementation.rs new file mode 100644 index 000000000..bf1215b71 --- /dev/null +++ b/crates/bindings/src/dummy_avalon_pool_implementation.rs @@ -0,0 +1,940 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface DummyAvalonPoolImplementation { + constructor(address _avalonToken, bool _doSupply); + + function supply(address, uint256 amount, address onBehalfOf, uint16) external; + function withdraw(address, uint256, address) external pure returns (uint256); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_avalonToken", + "type": "address", + "internalType": "contract ArbitaryErc20" + }, + { + "name": "_doSupply", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "supply", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "onBehalfOf", + "type": "address", + "internalType": "address" + }, + { + "name": "", + "type": "uint16", + "internalType": "uint16" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "withdraw", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + }, + { + "name": "", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + } +] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod DummyAvalonPoolImplementation { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x6080604052348015600e575f5ffd5b506040516102fe3803806102fe833981016040819052602b916066565b5f80546001600160a01b039093166001600160a01b0319921515600160a01b02929092166001600160a81b03199093169290921717905560aa565b5f5f604083850312156076575f5ffd5b82516001600160a01b0381168114608b575f5ffd5b60208401519092508015158114609f575f5ffd5b809150509250929050565b610247806100b75f395ff3fe608060405234801561000f575f5ffd5b5060043610610034575f3560e01c8063617ba0371461003857806369328dec1461004d575b5f5ffd5b61004b610046366004610160565b610075565b005b61006361005b3660046101b2565b5f9392505050565b60405190815260200160405180910390f35b5f5474010000000000000000000000000000000000000000900460ff1615610132575f546040517fa9059cbb00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8481166004830152602482018690529091169063a9059cbb906044016020604051808303815f875af115801561010c573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061013091906101eb565b505b50505050565b803573ffffffffffffffffffffffffffffffffffffffff8116811461015b575f5ffd5b919050565b5f5f5f5f60808587031215610173575f5ffd5b61017c85610138565b93506020850135925061019160408601610138565b9150606085013561ffff811681146101a7575f5ffd5b939692955090935050565b5f5f5f606084860312156101c4575f5ffd5b6101cd84610138565b9250602084013591506101e260408501610138565b90509250925092565b5f602082840312156101fb575f5ffd5b8151801515811461020a575f5ffd5b939250505056fea264697066735822122053c4cc04f9e8e633eb3b781a2eef09f6394d8f7dcfcfe674f20a92a8b04ce71d64736f6c634300081c0033 + /// ``` + #[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`@Qa\x02\xFE8\x03\x80a\x02\xFE\x839\x81\x01`@\x81\x90R`+\x91`fV[_\x80T`\x01`\x01`\xA0\x1B\x03\x90\x93\x16`\x01`\x01`\xA0\x1B\x03\x19\x92\x15\x15`\x01`\xA0\x1B\x02\x92\x90\x92\x16`\x01`\x01`\xA8\x1B\x03\x19\x90\x93\x16\x92\x90\x92\x17\x17\x90U`\xAAV[__`@\x83\x85\x03\x12\x15`vW__\xFD[\x82Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14`\x8BW__\xFD[` \x84\x01Q\x90\x92P\x80\x15\x15\x81\x14`\x9FW__\xFD[\x80\x91PP\x92P\x92\x90PV[a\x02G\x80a\0\xB7_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x004W_5`\xE0\x1C\x80ca{\xA07\x14a\08W\x80ci2\x8D\xEC\x14a\0MW[__\xFD[a\0Ka\0F6`\x04a\x01`V[a\0uV[\0[a\0ca\0[6`\x04a\x01\xB2V[_\x93\x92PPPV[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[_Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x012W_T`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R\x90\x91\x16\x90c\xA9\x05\x9C\xBB\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\x0CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x010\x91\x90a\x01\xEBV[P[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\x01[W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x01sW__\xFD[a\x01|\x85a\x018V[\x93P` \x85\x015\x92Pa\x01\x91`@\x86\x01a\x018V[\x91P``\x85\x015a\xFF\xFF\x81\x16\x81\x14a\x01\xA7W__\xFD[\x93\x96\x92\x95P\x90\x93PPV[___``\x84\x86\x03\x12\x15a\x01\xC4W__\xFD[a\x01\xCD\x84a\x018V[\x92P` \x84\x015\x91Pa\x01\xE2`@\x85\x01a\x018V[\x90P\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a\x01\xFBW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x02\nW__\xFD[\x93\x92PPPV\xFE\xA2dipfsX\"\x12 S\xC4\xCC\x04\xF9\xE8\xE63\xEB;x\x1A.\xEF\t\xF69M\x8F}\xCF\xCF\xE6t\xF2\n\x92\xA8\xB0L\xE7\x1DdsolcC\0\x08\x1C\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x608060405234801561000f575f5ffd5b5060043610610034575f3560e01c8063617ba0371461003857806369328dec1461004d575b5f5ffd5b61004b610046366004610160565b610075565b005b61006361005b3660046101b2565b5f9392505050565b60405190815260200160405180910390f35b5f5474010000000000000000000000000000000000000000900460ff1615610132575f546040517fa9059cbb00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8481166004830152602482018690529091169063a9059cbb906044016020604051808303815f875af115801561010c573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061013091906101eb565b505b50505050565b803573ffffffffffffffffffffffffffffffffffffffff8116811461015b575f5ffd5b919050565b5f5f5f5f60808587031215610173575f5ffd5b61017c85610138565b93506020850135925061019160408601610138565b9150606085013561ffff811681146101a7575f5ffd5b939692955090935050565b5f5f5f606084860312156101c4575f5ffd5b6101cd84610138565b9250602084013591506101e260408501610138565b90509250925092565b5f602082840312156101fb575f5ffd5b8151801515811461020a575f5ffd5b939250505056fea264697066735822122053c4cc04f9e8e633eb3b781a2eef09f6394d8f7dcfcfe674f20a92a8b04ce71d64736f6c634300081c0033 + /// ``` + #[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\x80ca{\xA07\x14a\08W\x80ci2\x8D\xEC\x14a\0MW[__\xFD[a\0Ka\0F6`\x04a\x01`V[a\0uV[\0[a\0ca\0[6`\x04a\x01\xB2V[_\x93\x92PPPV[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[_Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x012W_T`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R\x90\x91\x16\x90c\xA9\x05\x9C\xBB\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\x0CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x010\x91\x90a\x01\xEBV[P[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\x01[W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x01sW__\xFD[a\x01|\x85a\x018V[\x93P` \x85\x015\x92Pa\x01\x91`@\x86\x01a\x018V[\x91P``\x85\x015a\xFF\xFF\x81\x16\x81\x14a\x01\xA7W__\xFD[\x93\x96\x92\x95P\x90\x93PPV[___``\x84\x86\x03\x12\x15a\x01\xC4W__\xFD[a\x01\xCD\x84a\x018V[\x92P` \x84\x015\x91Pa\x01\xE2`@\x85\x01a\x018V[\x90P\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a\x01\xFBW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x02\nW__\xFD[\x93\x92PPPV\xFE\xA2dipfsX\"\x12 S\xC4\xCC\x04\xF9\xE8\xE63\xEB;x\x1A.\xEF\t\xF69M\x8F}\xCF\xCF\xE6t\xF2\n\x92\xA8\xB0L\xE7\x1DdsolcC\0\x08\x1C\x003", + ); + /**Constructor`. +```solidity +constructor(address _avalonToken, bool _doSupply); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _avalonToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _doSupply: bool, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._avalonToken, value._doSupply) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _avalonToken: tuple.0, + _doSupply: 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> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._avalonToken, + ), + ::tokenize( + &self._doSupply, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `supply(address,uint256,address,uint16)` and selector `0x617ba037`. +```solidity +function supply(address, uint256 amount, address onBehalfOf, uint16) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct supplyCall { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub onBehalfOf: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _3: u16, + } + ///Container type for the return parameters of the [`supply(address,uint256,address,uint16)`](supplyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct supplyReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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<16>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Address, + u16, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: supplyCall) -> Self { + (value._0, value.amount, value.onBehalfOf, value._3) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for supplyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _0: tuple.0, + amount: tuple.1, + onBehalfOf: tuple.2, + _3: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: supplyReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for supplyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl supplyReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for supplyCall { + 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<16>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = supplyReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "supply(address,uint256,address,uint16)"; + const SELECTOR: [u8; 4] = [97u8, 123u8, 160u8, 55u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._0, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ::tokenize( + &self.onBehalfOf, + ), + as alloy_sol_types::SolType>::tokenize(&self._3), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + supplyReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `withdraw(address,uint256,address)` and selector `0x69328dec`. +```solidity +function withdraw(address, uint256, address) external pure returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct withdrawCall { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _1: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub _2: alloy::sol_types::private::Address, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`withdraw(address,uint256,address)`](withdrawCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct withdrawReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: withdrawCall) -> Self { + (value._0, value._1, value._2) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for withdrawCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _0: tuple.0, + _1: tuple.1, + _2: tuple.2, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: withdrawReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for withdrawReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[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::Address, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "withdraw(address,uint256,address)"; + const SELECTOR: [u8; 4] = [105u8, 50u8, 141u8, 236u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._0, + ), + as alloy_sol_types::SolType>::tokenize(&self._1), + ::tokenize( + &self._2, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: withdrawReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: withdrawReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`DummyAvalonPoolImplementation`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum DummyAvalonPoolImplementationCalls { + #[allow(missing_docs)] + supply(supplyCall), + #[allow(missing_docs)] + withdraw(withdrawCall), + } + #[automatically_derived] + impl DummyAvalonPoolImplementationCalls { + /// 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]] = &[ + [97u8, 123u8, 160u8, 55u8], + [105u8, 50u8, 141u8, 236u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for DummyAvalonPoolImplementationCalls { + const NAME: &'static str = "DummyAvalonPoolImplementationCalls"; + const MIN_DATA_LENGTH: usize = 96usize; + const COUNT: usize = 2usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::supply(_) => ::SELECTOR, + Self::withdraw(_) => ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn supply( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyAvalonPoolImplementationCalls::supply) + } + supply + }, + { + fn withdraw( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyAvalonPoolImplementationCalls::withdraw) + } + withdraw + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn supply( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyAvalonPoolImplementationCalls::supply) + } + supply + }, + { + fn withdraw( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyAvalonPoolImplementationCalls::withdraw) + } + withdraw + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::supply(inner) => { + ::abi_encoded_size(inner) + } + Self::withdraw(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::supply(inner) => { + ::abi_encode_raw(inner, out) + } + Self::withdraw(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`DummyAvalonPoolImplementation`](self) contract instance. + +See the [wrapper's documentation](`DummyAvalonPoolImplementationInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> DummyAvalonPoolImplementationInstance { + DummyAvalonPoolImplementationInstance::::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: alloy_contract::private::Network, + >( + provider: P, + _avalonToken: alloy::sol_types::private::Address, + _doSupply: bool, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + DummyAvalonPoolImplementationInstance::< + P, + N, + >::deploy(provider, _avalonToken, _doSupply) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + _avalonToken: alloy::sol_types::private::Address, + _doSupply: bool, + ) -> alloy_contract::RawCallBuilder { + DummyAvalonPoolImplementationInstance::< + P, + N, + >::deploy_builder(provider, _avalonToken, _doSupply) + } + /**A [`DummyAvalonPoolImplementation`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`DummyAvalonPoolImplementation`](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 DummyAvalonPoolImplementationInstance< + P, + N = alloy_contract::private::Ethereum, + > { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for DummyAvalonPoolImplementationInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("DummyAvalonPoolImplementationInstance") + .field(&self.address) + .finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummyAvalonPoolImplementationInstance { + /**Creates a new wrapper around an on-chain [`DummyAvalonPoolImplementation`](self) contract instance. + +See the [wrapper's documentation](`DummyAvalonPoolImplementationInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + _avalonToken: alloy::sol_types::private::Address, + _doSupply: bool, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(provider, _avalonToken, _doSupply); + 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, + _avalonToken: alloy::sol_types::private::Address, + _doSupply: bool, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + _avalonToken, + _doSupply, + }, + )[..], + ] + .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 DummyAvalonPoolImplementationInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider( + self, + ) -> DummyAvalonPoolImplementationInstance { + DummyAvalonPoolImplementationInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummyAvalonPoolImplementationInstance { + /// 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( + &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 [`supply`] function. + pub fn supply( + &self, + _0: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + onBehalfOf: alloy::sol_types::private::Address, + _3: u16, + ) -> alloy_contract::SolCallBuilder<&P, supplyCall, N> { + self.call_builder( + &supplyCall { + _0, + amount, + onBehalfOf, + _3, + }, + ) + } + ///Creates a new call builder for the [`withdraw`] function. + pub fn withdraw( + &self, + _0: alloy::sol_types::private::Address, + _1: alloy::sol_types::private::primitives::aliases::U256, + _2: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, withdrawCall, N> { + self.call_builder(&withdrawCall { _0, _1, _2 }) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummyAvalonPoolImplementationInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/dummy_bedrock_vault_implementation.rs b/crates/bindings/src/dummy_bedrock_vault_implementation.rs new file mode 100644 index 000000000..4cadfb410 --- /dev/null +++ b/crates/bindings/src/dummy_bedrock_vault_implementation.rs @@ -0,0 +1,1060 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface DummyBedrockVaultImplementation { + constructor(address _uniBtcToken, bool _doMint); + + function mint(address, uint256 amount) external; + function redeem(address token, uint256 amount) external; + function uniBTC() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_uniBtcToken", + "type": "address", + "internalType": "contract ArbitaryErc20" + }, + { + "name": "_doMint", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "mint", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "redeem", + "inputs": [ + { + "name": "token", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "uniBTC", + "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 DummyBedrockVaultImplementation { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x6080604052348015600e575f5ffd5b506040516102a83803806102a8833981016040819052602b916066565b5f80546001600160a01b039093166001600160a01b0319921515600160a01b02929092166001600160a81b03199093169290921717905560aa565b5f5f604083850312156076575f5ffd5b82516001600160a01b0381168114608b575f5ffd5b60208401519092508015158114609f575f5ffd5b809150509250929050565b6101f1806100b75f395ff3fe608060405234801561000f575f5ffd5b506004361061003f575f3560e01c80631e9a69501461004357806340c10f191461005757806359f3d39b1461006a575b5f5ffd5b610055610051366004610153565b5050565b005b610055610065366004610153565b610095565b5f546040805173ffffffffffffffffffffffffffffffffffffffff9092168252519081900360200190f35b5f5474010000000000000000000000000000000000000000900460ff1615610051575f546040517fa9059cbb0000000000000000000000000000000000000000000000000000000081523360048201526024810183905273ffffffffffffffffffffffffffffffffffffffff9091169063a9059cbb906044016020604051808303815f875af115801561012a573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061014e9190610195565b505050565b5f5f60408385031215610164575f5ffd5b823573ffffffffffffffffffffffffffffffffffffffff81168114610187575f5ffd5b946020939093013593505050565b5f602082840312156101a5575f5ffd5b815180151581146101b4575f5ffd5b939250505056fea26469706673582212201b70e9eaf7912da9c6465df0c44462b2a7ac1d899bd092ca54040522be6f9a5264736f6c634300081c0033 + /// ``` + #[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`@Qa\x02\xA88\x03\x80a\x02\xA8\x839\x81\x01`@\x81\x90R`+\x91`fV[_\x80T`\x01`\x01`\xA0\x1B\x03\x90\x93\x16`\x01`\x01`\xA0\x1B\x03\x19\x92\x15\x15`\x01`\xA0\x1B\x02\x92\x90\x92\x16`\x01`\x01`\xA8\x1B\x03\x19\x90\x93\x16\x92\x90\x92\x17\x17\x90U`\xAAV[__`@\x83\x85\x03\x12\x15`vW__\xFD[\x82Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14`\x8BW__\xFD[` \x84\x01Q\x90\x92P\x80\x15\x15\x81\x14`\x9FW__\xFD[\x80\x91PP\x92P\x92\x90PV[a\x01\xF1\x80a\0\xB7_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0?W_5`\xE0\x1C\x80c\x1E\x9AiP\x14a\0CW\x80c@\xC1\x0F\x19\x14a\0WW\x80cY\xF3\xD3\x9B\x14a\0jW[__\xFD[a\0Ua\0Q6`\x04a\x01SV[PPV[\0[a\0Ua\0e6`\x04a\x01SV[a\0\x95V[_T`@\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[_Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\0QW_T`@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\x81R3`\x04\x82\x01R`$\x81\x01\x83\x90Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x90c\xA9\x05\x9C\xBB\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01*W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01N\x91\x90a\x01\x95V[PPPV[__`@\x83\x85\x03\x12\x15a\x01dW__\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\x01\x87W__\xFD[\x94` \x93\x90\x93\x015\x93PPPV[_` \x82\x84\x03\x12\x15a\x01\xA5W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x01\xB4W__\xFD[\x93\x92PPPV\xFE\xA2dipfsX\"\x12 \x1Bp\xE9\xEA\xF7\x91-\xA9\xC6F]\xF0\xC4Db\xB2\xA7\xAC\x1D\x89\x9B\xD0\x92\xCAT\x04\x05\"\xBEo\x9ARdsolcC\0\x08\x1C\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x608060405234801561000f575f5ffd5b506004361061003f575f3560e01c80631e9a69501461004357806340c10f191461005757806359f3d39b1461006a575b5f5ffd5b610055610051366004610153565b5050565b005b610055610065366004610153565b610095565b5f546040805173ffffffffffffffffffffffffffffffffffffffff9092168252519081900360200190f35b5f5474010000000000000000000000000000000000000000900460ff1615610051575f546040517fa9059cbb0000000000000000000000000000000000000000000000000000000081523360048201526024810183905273ffffffffffffffffffffffffffffffffffffffff9091169063a9059cbb906044016020604051808303815f875af115801561012a573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061014e9190610195565b505050565b5f5f60408385031215610164575f5ffd5b823573ffffffffffffffffffffffffffffffffffffffff81168114610187575f5ffd5b946020939093013593505050565b5f602082840312156101a5575f5ffd5b815180151581146101b4575f5ffd5b939250505056fea26469706673582212201b70e9eaf7912da9c6465df0c44462b2a7ac1d899bd092ca54040522be6f9a5264736f6c634300081c0033 + /// ``` + #[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\x1E\x9AiP\x14a\0CW\x80c@\xC1\x0F\x19\x14a\0WW\x80cY\xF3\xD3\x9B\x14a\0jW[__\xFD[a\0Ua\0Q6`\x04a\x01SV[PPV[\0[a\0Ua\0e6`\x04a\x01SV[a\0\x95V[_T`@\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[_Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\0QW_T`@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\x81R3`\x04\x82\x01R`$\x81\x01\x83\x90Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x90c\xA9\x05\x9C\xBB\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01*W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01N\x91\x90a\x01\x95V[PPPV[__`@\x83\x85\x03\x12\x15a\x01dW__\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\x01\x87W__\xFD[\x94` \x93\x90\x93\x015\x93PPPV[_` \x82\x84\x03\x12\x15a\x01\xA5W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x01\xB4W__\xFD[\x93\x92PPPV\xFE\xA2dipfsX\"\x12 \x1Bp\xE9\xEA\xF7\x91-\xA9\xC6F]\xF0\xC4Db\xB2\xA7\xAC\x1D\x89\x9B\xD0\x92\xCAT\x04\x05\"\xBEo\x9ARdsolcC\0\x08\x1C\x003", + ); + /**Constructor`. +```solidity +constructor(address _uniBtcToken, bool _doMint); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _uniBtcToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _doMint: bool, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._uniBtcToken, value._doMint) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _uniBtcToken: tuple.0, + _doMint: 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> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._uniBtcToken, + ), + ::tokenize( + &self._doMint, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `mint(address,uint256)` and selector `0x40c10f19`. +```solidity +function mint(address, uint256 amount) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct mintCall { + #[allow(missing_docs)] + pub _0: 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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: mintCall) -> Self { + (value._0, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for mintCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _0: tuple.0, + amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: mintReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for mintReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl mintReturn { + fn _tokenize( + &self, + ) -> ::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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = mintReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "mint(address,uint256)"; + const SELECTOR: [u8; 4] = [64u8, 193u8, 15u8, 25u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._0, + ), + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `redeem(address,uint256)` and selector `0x1e9a6950`. +```solidity +function redeem(address token, uint256 amount) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct redeemCall { + #[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 [`redeem(address,uint256)`](redeemCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct redeemReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: redeemCall) -> Self { + (value.token, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for redeemCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + token: tuple.0, + amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: redeemReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for redeemReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl redeemReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for redeemCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = redeemReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "redeem(address,uint256)"; + const SELECTOR: [u8; 4] = [30u8, 154u8, 105u8, 80u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.token, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + redeemReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `uniBTC()` and selector `0x59f3d39b`. +```solidity +function uniBTC() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct uniBTCCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`uniBTC()`](uniBTCCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct uniBTCReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: uniBTCCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for uniBTCCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: uniBTCReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for uniBTCReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for uniBTCCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "uniBTC()"; + const SELECTOR: [u8; 4] = [89u8, 243u8, 211u8, 155u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: uniBTCReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: uniBTCReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`DummyBedrockVaultImplementation`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum DummyBedrockVaultImplementationCalls { + #[allow(missing_docs)] + mint(mintCall), + #[allow(missing_docs)] + redeem(redeemCall), + #[allow(missing_docs)] + uniBTC(uniBTCCall), + } + #[automatically_derived] + impl DummyBedrockVaultImplementationCalls { + /// 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]] = &[ + [30u8, 154u8, 105u8, 80u8], + [64u8, 193u8, 15u8, 25u8], + [89u8, 243u8, 211u8, 155u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for DummyBedrockVaultImplementationCalls { + const NAME: &'static str = "DummyBedrockVaultImplementationCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 3usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::mint(_) => ::SELECTOR, + Self::redeem(_) => ::SELECTOR, + Self::uniBTC(_) => ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn redeem( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyBedrockVaultImplementationCalls::redeem) + } + redeem + }, + { + fn mint( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyBedrockVaultImplementationCalls::mint) + } + mint + }, + { + fn uniBTC( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyBedrockVaultImplementationCalls::uniBTC) + } + uniBTC + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn redeem( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyBedrockVaultImplementationCalls::redeem) + } + redeem + }, + { + fn mint( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyBedrockVaultImplementationCalls::mint) + } + mint + }, + { + fn uniBTC( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyBedrockVaultImplementationCalls::uniBTC) + } + uniBTC + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::mint(inner) => { + ::abi_encoded_size(inner) + } + Self::redeem(inner) => { + ::abi_encoded_size(inner) + } + Self::uniBTC(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::mint(inner) => { + ::abi_encode_raw(inner, out) + } + Self::redeem(inner) => { + ::abi_encode_raw(inner, out) + } + Self::uniBTC(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`DummyBedrockVaultImplementation`](self) contract instance. + +See the [wrapper's documentation](`DummyBedrockVaultImplementationInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> DummyBedrockVaultImplementationInstance { + DummyBedrockVaultImplementationInstance::::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: alloy_contract::private::Network, + >( + provider: P, + _uniBtcToken: alloy::sol_types::private::Address, + _doMint: bool, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + DummyBedrockVaultImplementationInstance::< + P, + N, + >::deploy(provider, _uniBtcToken, _doMint) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + _uniBtcToken: alloy::sol_types::private::Address, + _doMint: bool, + ) -> alloy_contract::RawCallBuilder { + DummyBedrockVaultImplementationInstance::< + P, + N, + >::deploy_builder(provider, _uniBtcToken, _doMint) + } + /**A [`DummyBedrockVaultImplementation`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`DummyBedrockVaultImplementation`](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 DummyBedrockVaultImplementationInstance< + P, + N = alloy_contract::private::Ethereum, + > { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for DummyBedrockVaultImplementationInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("DummyBedrockVaultImplementationInstance") + .field(&self.address) + .finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummyBedrockVaultImplementationInstance { + /**Creates a new wrapper around an on-chain [`DummyBedrockVaultImplementation`](self) contract instance. + +See the [wrapper's documentation](`DummyBedrockVaultImplementationInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + _uniBtcToken: alloy::sol_types::private::Address, + _doMint: bool, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(provider, _uniBtcToken, _doMint); + 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, + _uniBtcToken: alloy::sol_types::private::Address, + _doMint: bool, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + _uniBtcToken, + _doMint, + }, + )[..], + ] + .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 DummyBedrockVaultImplementationInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider( + self, + ) -> DummyBedrockVaultImplementationInstance { + DummyBedrockVaultImplementationInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummyBedrockVaultImplementationInstance { + /// 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( + &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 [`mint`] function. + pub fn mint( + &self, + _0: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> { + self.call_builder(&mintCall { _0, amount }) + } + ///Creates a new call builder for the [`redeem`] function. + pub fn redeem( + &self, + token: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, redeemCall, N> { + self.call_builder(&redeemCall { token, amount }) + } + ///Creates a new call builder for the [`uniBTC`] function. + pub fn uniBTC(&self) -> alloy_contract::SolCallBuilder<&P, uniBTCCall, N> { + self.call_builder(&uniBTCCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummyBedrockVaultImplementationInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/dummy_ionic_pool.rs b/crates/bindings/src/dummy_ionic_pool.rs new file mode 100644 index 000000000..a67371f0c --- /dev/null +++ b/crates/bindings/src/dummy_ionic_pool.rs @@ -0,0 +1,842 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface DummyIonicPool { + constructor(bool _doEnterMarkets); + + function enterMarkets(address[] memory cTokens) external view returns (uint256[] memory); + function exitMarket(address) external pure returns (uint256); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_doEnterMarkets", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "enterMarkets", + "inputs": [ + { + "name": "cTokens", + "type": "address[]", + "internalType": "address[]" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256[]", + "internalType": "uint256[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "exitMarket", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + } +] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod DummyIonicPool { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x6080604052348015600e575f5ffd5b50604051610392380380610392833981016040819052602b91603f565b5f805460ff19169115159190911790556063565b5f60208284031215604e575f5ffd5b81518015158114605c575f5ffd5b9392505050565b610322806100705f395ff3fe608060405234801561000f575f5ffd5b5060043610610034575f3560e01c8063c299823814610038578063ede4edd014610061575b5f5ffd5b61004b610046366004610174565b610082565b604051610058919061025d565b60405180910390f35b61007461006f36600461029f565b505f90565b604051908152602001610058565b5f5460609060ff16156100d957815167ffffffffffffffff8111156100a9576100a961011f565b6040519080825280602002602001820160405280156100d2578160200160208202803683370190505b5092915050565b6040805160018082528183019092525f91602080830190803683370190505090506001815f8151811061010e5761010e6102bf565b602090810291909101015292915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b803573ffffffffffffffffffffffffffffffffffffffff8116811461016f575f5ffd5b919050565b5f60208284031215610184575f5ffd5b813567ffffffffffffffff81111561019a575f5ffd5b8201601f810184136101aa575f5ffd5b803567ffffffffffffffff8111156101c4576101c461011f565b8060051b6040517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0603f830116810181811067ffffffffffffffff8211171561020f5761020f61011f565b60405291825260208184018101929081018784111561022c575f5ffd5b6020850194505b83851015610252576102448561014c565b815260209485019401610233565b509695505050505050565b602080825282518282018190525f918401906040840190835b81811015610294578351835260209384019390920191600101610276565b509095945050505050565b5f602082840312156102af575f5ffd5b6102b88261014c565b9392505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffdfea26469706673582212203c556799d4a9c9701cb4512c4ec0ccdbf14634228f9b490e15920fdeea36b7a864736f6c634300081c0033 + /// ``` + #[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`@Qa\x03\x928\x03\x80a\x03\x92\x839\x81\x01`@\x81\x90R`+\x91`?V[_\x80T`\xFF\x19\x16\x91\x15\x15\x91\x90\x91\x17\x90U`cV[_` \x82\x84\x03\x12\x15`NW__\xFD[\x81Q\x80\x15\x15\x81\x14`\\W__\xFD[\x93\x92PPPV[a\x03\"\x80a\0p_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x004W_5`\xE0\x1C\x80c\xC2\x99\x828\x14a\08W\x80c\xED\xE4\xED\xD0\x14a\0aW[__\xFD[a\0Ka\0F6`\x04a\x01tV[a\0\x82V[`@Qa\0X\x91\x90a\x02]V[`@Q\x80\x91\x03\x90\xF3[a\0ta\0o6`\x04a\x02\x9FV[P_\x90V[`@Q\x90\x81R` \x01a\0XV[_T``\x90`\xFF\x16\x15a\0\xD9W\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\0\xA9Wa\0\xA9a\x01\x1FV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\0\xD2W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x92\x91PPV[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91` \x80\x83\x01\x90\x806\x837\x01\x90PP\x90P`\x01\x81_\x81Q\x81\x10a\x01\x0EWa\x01\x0Ea\x02\xBFV[` \x90\x81\x02\x91\x90\x91\x01\x01R\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`A`\x04R`$_\xFD[\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\x01oW__\xFD[\x91\x90PV[_` \x82\x84\x03\x12\x15a\x01\x84W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x01\x9AW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x01\xAAW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x01\xC4Wa\x01\xC4a\x01\x1FV[\x80`\x05\x1B`@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`?\x83\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x02\x0FWa\x02\x0Fa\x01\x1FV[`@R\x91\x82R` \x81\x84\x01\x81\x01\x92\x90\x81\x01\x87\x84\x11\x15a\x02,W__\xFD[` \x85\x01\x94P[\x83\x85\x10\x15a\x02RWa\x02D\x85a\x01LV[\x81R` \x94\x85\x01\x94\x01a\x023V[P\x96\x95PPPPPPV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x02\x94W\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x02vV[P\x90\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x02\xAFW__\xFD[a\x02\xB8\x82a\x01LV[\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\xFE\xA2dipfsX\"\x12 = (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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._doEnterMarkets,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _doEnterMarkets: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolConstructor for constructorCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Bool,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._doEnterMarkets, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `enterMarkets(address[])` and selector `0xc2998238`. +```solidity +function enterMarkets(address[] memory cTokens) external view returns (uint256[] memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct enterMarketsCall { + #[allow(missing_docs)] + pub cTokens: alloy::sol_types::private::Vec, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`enterMarkets(address[])`](enterMarketsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct enterMarketsReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: enterMarketsCall) -> Self { + (value.cTokens,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for enterMarketsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { cTokens: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array>, + ); + #[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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: enterMarketsReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for enterMarketsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for enterMarketsCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::primitives::aliases::U256, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array>, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "enterMarkets(address[])"; + const SELECTOR: [u8; 4] = [194u8, 153u8, 130u8, 56u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.cTokens), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + , + > as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: enterMarketsReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: enterMarketsReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `exitMarket(address)` and selector `0xede4edd0`. +```solidity +function exitMarket(address) external pure returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct exitMarketCall(pub alloy::sol_types::private::Address); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`exitMarket(address)`](exitMarketCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct exitMarketReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: exitMarketCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for exitMarketCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: exitMarketReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for exitMarketReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for exitMarketCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "exitMarket(address)"; + const SELECTOR: [u8; 4] = [237u8, 228u8, 237u8, 208u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.0, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: exitMarketReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: exitMarketReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`DummyIonicPool`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum DummyIonicPoolCalls { + #[allow(missing_docs)] + enterMarkets(enterMarketsCall), + #[allow(missing_docs)] + exitMarket(exitMarketCall), + } + #[automatically_derived] + impl DummyIonicPoolCalls { + /// 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]] = &[ + [194u8, 153u8, 130u8, 56u8], + [237u8, 228u8, 237u8, 208u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for DummyIonicPoolCalls { + const NAME: &'static str = "DummyIonicPoolCalls"; + const MIN_DATA_LENGTH: usize = 32usize; + const COUNT: usize = 2usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::enterMarkets(_) => { + ::SELECTOR + } + Self::exitMarket(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn enterMarkets( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummyIonicPoolCalls::enterMarkets) + } + enterMarkets + }, + { + fn exitMarket( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummyIonicPoolCalls::exitMarket) + } + exitMarket + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn enterMarkets( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyIonicPoolCalls::enterMarkets) + } + enterMarkets + }, + { + fn exitMarket( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyIonicPoolCalls::exitMarket) + } + exitMarket + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::enterMarkets(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::exitMarket(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::enterMarkets(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::exitMarket(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`DummyIonicPool`](self) contract instance. + +See the [wrapper's documentation](`DummyIonicPoolInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> DummyIonicPoolInstance { + DummyIonicPoolInstance::::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: alloy_contract::private::Network, + >( + provider: P, + _doEnterMarkets: bool, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + DummyIonicPoolInstance::::deploy(provider, _doEnterMarkets) + } + /**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: alloy_contract::private::Network, + >(provider: P, _doEnterMarkets: bool) -> alloy_contract::RawCallBuilder { + DummyIonicPoolInstance::::deploy_builder(provider, _doEnterMarkets) + } + /**A [`DummyIonicPool`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`DummyIonicPool`](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 DummyIonicPoolInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for DummyIonicPoolInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("DummyIonicPoolInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummyIonicPoolInstance { + /**Creates a new wrapper around an on-chain [`DummyIonicPool`](self) contract instance. + +See the [wrapper's documentation](`DummyIonicPoolInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + _doEnterMarkets: bool, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(provider, _doEnterMarkets); + 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, + _doEnterMarkets: bool, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { _doEnterMarkets }, + )[..], + ] + .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 DummyIonicPoolInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> DummyIonicPoolInstance { + DummyIonicPoolInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummyIonicPoolInstance { + /// 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( + &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 [`enterMarkets`] function. + pub fn enterMarkets( + &self, + cTokens: alloy::sol_types::private::Vec, + ) -> alloy_contract::SolCallBuilder<&P, enterMarketsCall, N> { + self.call_builder(&enterMarketsCall { cTokens }) + } + ///Creates a new call builder for the [`exitMarket`] function. + pub fn exitMarket( + &self, + _0: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, exitMarketCall, N> { + self.call_builder(&exitMarketCall(_0)) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummyIonicPoolInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/dummy_ionic_token.rs b/crates/bindings/src/dummy_ionic_token.rs new file mode 100644 index 000000000..1553bda2a --- /dev/null +++ b/crates/bindings/src/dummy_ionic_token.rs @@ -0,0 +1,4713 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface DummyIonicToken { + event Approval(address indexed owner, address indexed spender, uint256 value); + event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); + event Transfer(address indexed from, address indexed to, uint256 value); + + constructor(string name_, string symbol_, bool _doMint, bool _suppressMintError); + + 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 mint(uint256 mintAmount) external returns (uint256); + function name() external view returns (string memory); + function owner() external view returns (address); + function redeem(uint256) external pure returns (uint256); + function renounceOwnership() external; + function sudoMint(address to, uint256 amount) external; + function symbol() external view returns (string memory); + function totalSupply() external view returns (uint256); + function transfer(address to, uint256 amount) external returns (bool); + function transferFrom(address from, address to, uint256 amount) external returns (bool); + function transferOwnership(address newOwner) external; +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "name_", + "type": "string", + "internalType": "string" + }, + { + "name": "symbol_", + "type": "string", + "internalType": "string" + }, + { + "name": "_doMint", + "type": "bool", + "internalType": "bool" + }, + { + "name": "_suppressMintError", + "type": "bool", + "internalType": "bool" + } + ], + "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": "mint", + "inputs": [ + { + "name": "mintAmount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "name", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "owner", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "redeem", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "renounceOwnership", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "sudoMint", + "inputs": [ + { + "name": "to", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "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": "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" + }, + { + "type": "function", + "name": "transferOwnership", + "inputs": [ + { + "name": "newOwner", + "type": "address", + "internalType": "address" + } + ], + "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": "OwnershipTransferred", + "inputs": [ + { + "name": "previousOwner", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "newOwner", + "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 DummyIonicToken { + use super::*; + use alloy::sol_types as 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__\xFD[P`@Qa\x11U8\x03\x80a\x11U\x839\x81\x01`@\x81\x90Ra\0.\x91a\x01\xA2V[\x83\x83`\x03a\0<\x83\x82a\x02\xABV[P`\x04a\0I\x82\x82a\x02\xABV[PPPa\0ba\0]a\0\x9C` \x1B` \x1CV[a\0\xA0V[`\x05\x80Ta\xFF\xFF`\xA0\x1B\x19\x16`\x01`\xA0\x1B\x93\x15\x15\x93\x90\x93\x02`\xFF`\xA8\x1B\x19\x16\x92\x90\x92\x17`\x01`\xA8\x1B\x91\x15\x15\x91\x90\x91\x02\x17\x90UPa\x03e\x90PV[3\x90V[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x01`\x01`\xA0\x1B\x03\x19\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x82`\x1F\x83\x01\x12a\x01\x14W__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01-Wa\x01-a\0\xF1V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x01[Wa\x01[a\0\xF1V[`@R\x81\x81R\x83\x82\x01` \x01\x85\x10\x15a\x01rW__\xFD[\x81` \x85\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[\x80Q\x80\x15\x15\x81\x14a\x01\x9DW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x01\xB5W__\xFD[\x84Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\xCAW__\xFD[a\x01\xD6\x87\x82\x88\x01a\x01\x05V[` \x87\x01Q\x90\x95P\x90P`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\xF3W__\xFD[a\x01\xFF\x87\x82\x88\x01a\x01\x05V[\x93PPa\x02\x0E`@\x86\x01a\x01\x8EV[\x91Pa\x02\x1C``\x86\x01a\x01\x8EV[\x90P\x92\x95\x91\x94P\x92PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x02;W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x02YWcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\x02\xA6W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x02\x84WP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x02\xA3W_\x81U`\x01\x01a\x02\x90V[PP[PPPV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x02\xC4Wa\x02\xC4a\0\xF1V[a\x02\xD8\x81a\x02\xD2\x84Ta\x02'V[\x84a\x02_V[` `\x1F\x82\x11`\x01\x81\x14a\x03\nW_\x83\x15a\x02\xF3WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x02\xA3V[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x039W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x03\x19V[P\x84\x82\x10\x15a\x03VW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[a\r\xE3\x80a\x03r_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cqP\x18\xA6\x11a\0\xADW\x80c\xA4W\xC2\xD7\x11a\0}W\x80c\xDB\0ju\x11a\0cW\x80c\xDB\0ju\x14a\x02BW\x80c\xDDb\xED>\x14a\x02UW\x80c\xF2\xFD\xE3\x8B\x14a\x02\x8DW__\xFD[\x80c\xA4W\xC2\xD7\x14a\x02\x1CW\x80c\xA9\x05\x9C\xBB\x14a\x02/W__\xFD[\x80cqP\x18\xA6\x14a\x01\xDEW\x80c\x8D\xA5\xCB[\x14a\x01\xE6W\x80c\x95\xD8\x9BA\x14a\x02\x01W\x80c\xA0q-h\x14a\x02\tW__\xFD[\x80c-h\x8C\xA8\x11a\0\xE8W\x80c-h\x8C\xA8\x14a\x01\x7FW\x80c1<\xE5g\x14a\x01\x94W\x80c9P\x93Q\x14a\x01\xA3W\x80cp\xA0\x821\x14a\x01\xB6W__\xFD[\x80c\x06\xFD\xDE\x03\x14a\x01\x19W\x80c\t^\xA7\xB3\x14a\x017W\x80c\x18\x16\r\xDD\x14a\x01ZW\x80c#\xB8r\xDD\x14a\x01lW[__\xFD[a\x01!a\x02\xA0V[`@Qa\x01.\x91\x90a\x0B\xECV[`@Q\x80\x91\x03\x90\xF3[a\x01Ja\x01E6`\x04a\x0CZV[a\x030V[`@Q\x90\x15\x15\x81R` \x01a\x01.V[`\x02T[`@Q\x90\x81R` \x01a\x01.V[a\x01Ja\x01z6`\x04a\x0C\x82V[a\x03IV[a\x01\x92a\x01\x8D6`\x04a\x0CZV[a\x03lV[\0[`@Q`\x12\x81R` \x01a\x01.V[a\x01Ja\x01\xB16`\x04a\x0CZV[a\x03\xD9V[a\x01^a\x01\xC46`\x04a\x0C\xBCV[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R` \x81\x90R`@\x90 T\x90V[a\x01\x92a\x04\x17V[`\x05T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01.V[a\x01!a\x04|V[a\x01^a\x02\x176`\x04a\x0C\xDCV[a\x04\x8BV[a\x01Ja\x02*6`\x04a\x0CZV[a\x04\xF4V[a\x01Ja\x02=6`\x04a\x0CZV[a\x05\x9DV[a\x01^a\x02P6`\x04a\x0C\xDCV[P_\x90V[a\x01^a\x02c6`\x04a\x0C\xF3V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[a\x01\x92a\x02\x9B6`\x04a\x0C\xBCV[a\x05\xAAV[```\x03\x80Ta\x02\xAF\x90a\r$V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\xDB\x90a\r$V[\x80\x15a\x03&W\x80`\x1F\x10a\x02\xFDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03&V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\tW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[_3a\x03=\x81\x85\x85a\x06\x8CV[`\x01\x91PP[\x92\x91PPV[_3a\x03V\x85\x82\x85a\x07\xE3V[a\x03a\x85\x85\x85a\x08\x92V[P`\x01\x94\x93PPPPV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x03\xCBW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\xD5\x82\x82a\n\xA7V[PPV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90a\x03=\x90\x82\x90\x86\x90a\x04\x12\x90\x87\x90a\ruV[a\x06\x8CV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x04qW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03\xC2V[a\x04z_a\x0B\x83V[V[```\x04\x80Ta\x02\xAF\x90a\r$V[`\x05T_\x90u\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x04\xB8WP_\x91\x90PV[`\x05Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x04\xECWa\x04\xE53\x83a\n\xA7V[P_\x91\x90PV[P`\x01\x91\x90PV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90\x83\x81\x10\x15a\x05\x90W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[a\x03a\x82\x86\x86\x84\x03a\x06\x8CV[_3a\x03=\x81\x85\x85a\x08\x92V[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x06\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x06\x80W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01R\x7Fddress\0\0\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\x03\xC2V[a\x06\x89\x81a\x0B\x83V[PV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x07\x07W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x07\x83W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\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[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R 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\x81\x14a\x08\x8CW\x81\x81\x10\x15a\x08\x7FW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FERC20: insufficient allowance\0\0\0`D\x82\x01R`d\x01a\x03\xC2V[a\x08\x8C\x84\x84\x84\x84\x03a\x06\x8CV[PPPPV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\t\x0EW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\t\x8AW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R` \x81\x90R`@\x90 T\x81\x81\x10\x15a\n\x18W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16_\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R\x90\x81 \x80T\x84\x92\x90a\nN\x90\x84\x90a\ruV[\x92PP\x81\x90UP\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\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\n\x9A\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3a\x08\x8CV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\n\xFDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FERC20: mint to the zero address\0`D\x82\x01R`d\x01a\x03\xC2V[\x80`\x02_\x82\x82Ta\x0B\x0E\x91\x90a\ruV[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x83\x92\x90a\x0B:\x90\x84\x90a\ruV[\x90\x91UPP`@Q\x81\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90_\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[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\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\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\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\x84\x01\x01\x91PP\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0CUW__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0CkW__\xFD[a\x0Ct\x83a\x0C?V[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x0C\x94W__\xFD[a\x0C\x9D\x84a\x0C?V[\x92Pa\x0C\xAB` \x85\x01a\x0C?V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\x0C\xCCW__\xFD[a\x0C\xD5\x82a\x0C?V[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x0C\xECW__\xFD[P5\x91\x90PV[__`@\x83\x85\x03\x12\x15a\r\x04W__\xFD[a\r\r\x83a\x0C?V[\x91Pa\r\x1B` \x84\x01a\x0C?V[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\r8W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\roW\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[P\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x03CW\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\xFE\xA2dipfsX\"\x12 Vn\xA9sL\xF4\x94:\xB1\x9A\xB4G\xAAe\x9A\xC7\x1E\xADVze\x8A7\xDEP\xFE\xCF\x03\xA6\xE6\xA0\xCAdsolcC\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\x01\x15W_5`\xE0\x1C\x80cqP\x18\xA6\x11a\0\xADW\x80c\xA4W\xC2\xD7\x11a\0}W\x80c\xDB\0ju\x11a\0cW\x80c\xDB\0ju\x14a\x02BW\x80c\xDDb\xED>\x14a\x02UW\x80c\xF2\xFD\xE3\x8B\x14a\x02\x8DW__\xFD[\x80c\xA4W\xC2\xD7\x14a\x02\x1CW\x80c\xA9\x05\x9C\xBB\x14a\x02/W__\xFD[\x80cqP\x18\xA6\x14a\x01\xDEW\x80c\x8D\xA5\xCB[\x14a\x01\xE6W\x80c\x95\xD8\x9BA\x14a\x02\x01W\x80c\xA0q-h\x14a\x02\tW__\xFD[\x80c-h\x8C\xA8\x11a\0\xE8W\x80c-h\x8C\xA8\x14a\x01\x7FW\x80c1<\xE5g\x14a\x01\x94W\x80c9P\x93Q\x14a\x01\xA3W\x80cp\xA0\x821\x14a\x01\xB6W__\xFD[\x80c\x06\xFD\xDE\x03\x14a\x01\x19W\x80c\t^\xA7\xB3\x14a\x017W\x80c\x18\x16\r\xDD\x14a\x01ZW\x80c#\xB8r\xDD\x14a\x01lW[__\xFD[a\x01!a\x02\xA0V[`@Qa\x01.\x91\x90a\x0B\xECV[`@Q\x80\x91\x03\x90\xF3[a\x01Ja\x01E6`\x04a\x0CZV[a\x030V[`@Q\x90\x15\x15\x81R` \x01a\x01.V[`\x02T[`@Q\x90\x81R` \x01a\x01.V[a\x01Ja\x01z6`\x04a\x0C\x82V[a\x03IV[a\x01\x92a\x01\x8D6`\x04a\x0CZV[a\x03lV[\0[`@Q`\x12\x81R` \x01a\x01.V[a\x01Ja\x01\xB16`\x04a\x0CZV[a\x03\xD9V[a\x01^a\x01\xC46`\x04a\x0C\xBCV[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R` \x81\x90R`@\x90 T\x90V[a\x01\x92a\x04\x17V[`\x05T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01.V[a\x01!a\x04|V[a\x01^a\x02\x176`\x04a\x0C\xDCV[a\x04\x8BV[a\x01Ja\x02*6`\x04a\x0CZV[a\x04\xF4V[a\x01Ja\x02=6`\x04a\x0CZV[a\x05\x9DV[a\x01^a\x02P6`\x04a\x0C\xDCV[P_\x90V[a\x01^a\x02c6`\x04a\x0C\xF3V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[a\x01\x92a\x02\x9B6`\x04a\x0C\xBCV[a\x05\xAAV[```\x03\x80Ta\x02\xAF\x90a\r$V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\xDB\x90a\r$V[\x80\x15a\x03&W\x80`\x1F\x10a\x02\xFDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03&V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\tW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[_3a\x03=\x81\x85\x85a\x06\x8CV[`\x01\x91PP[\x92\x91PPV[_3a\x03V\x85\x82\x85a\x07\xE3V[a\x03a\x85\x85\x85a\x08\x92V[P`\x01\x94\x93PPPPV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x03\xCBW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\xD5\x82\x82a\n\xA7V[PPV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90a\x03=\x90\x82\x90\x86\x90a\x04\x12\x90\x87\x90a\ruV[a\x06\x8CV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x04qW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03\xC2V[a\x04z_a\x0B\x83V[V[```\x04\x80Ta\x02\xAF\x90a\r$V[`\x05T_\x90u\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x04\xB8WP_\x91\x90PV[`\x05Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x04\xECWa\x04\xE53\x83a\n\xA7V[P_\x91\x90PV[P`\x01\x91\x90PV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90\x83\x81\x10\x15a\x05\x90W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[a\x03a\x82\x86\x86\x84\x03a\x06\x8CV[_3a\x03=\x81\x85\x85a\x08\x92V[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x06\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x06\x80W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01R\x7Fddress\0\0\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\x03\xC2V[a\x06\x89\x81a\x0B\x83V[PV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x07\x07W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x07\x83W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\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[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R 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\x81\x14a\x08\x8CW\x81\x81\x10\x15a\x08\x7FW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FERC20: insufficient allowance\0\0\0`D\x82\x01R`d\x01a\x03\xC2V[a\x08\x8C\x84\x84\x84\x84\x03a\x06\x8CV[PPPPV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\t\x0EW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\t\x8AW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R` \x81\x90R`@\x90 T\x81\x81\x10\x15a\n\x18W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16_\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R\x90\x81 \x80T\x84\x92\x90a\nN\x90\x84\x90a\ruV[\x92PP\x81\x90UP\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\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\n\x9A\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3a\x08\x8CV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\n\xFDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FERC20: mint to the zero address\0`D\x82\x01R`d\x01a\x03\xC2V[\x80`\x02_\x82\x82Ta\x0B\x0E\x91\x90a\ruV[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x83\x92\x90a\x0B:\x90\x84\x90a\ruV[\x90\x91UPP`@Q\x81\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90_\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[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\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\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\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\x84\x01\x01\x91PP\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0CUW__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0CkW__\xFD[a\x0Ct\x83a\x0C?V[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x0C\x94W__\xFD[a\x0C\x9D\x84a\x0C?V[\x92Pa\x0C\xAB` \x85\x01a\x0C?V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\x0C\xCCW__\xFD[a\x0C\xD5\x82a\x0C?V[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x0C\xECW__\xFD[P5\x91\x90PV[__`@\x83\x85\x03\x12\x15a\r\x04W__\xFD[a\r\r\x83a\x0C?V[\x91Pa\r\x1B` \x84\x01a\x0C?V[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\r8W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\roW\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[P\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x03CW\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\xFE\xA2dipfsX\"\x12 Vn\xA9sL\xF4\x94:\xB1\x9A\xB4G\xAAe\x9A\xC7\x1E\xADVze\x8A7\xDEP\xFE\xCF\x03\xA6\xE6\xA0\xCAdsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Approval { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + 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, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + owner: topics.1, + spender: topics.2, + value: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.value), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.owner, + ); + out[2usize] = ::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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for OwnershipTransferred { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + 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, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + previousOwner: topics.1, + newOwner: topics.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return 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) -> ::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() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.previousOwner, + ); + out[2usize] = ::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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Transfer { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + 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, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + from: topics.1, + to: topics.2, + value: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.value), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.from, + ); + out[2usize] = ::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_, bool _doMint, bool _suppressMintError); +```*/ + #[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, + #[allow(missing_docs)] + pub _doMint: bool, + #[allow(missing_docs)] + pub _suppressMintError: bool, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Bool, + alloy::sol_types::sol_data::Bool, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::String, + alloy::sol_types::private::String, + bool, + bool, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value.name_, value.symbol_, value._doMint, value._suppressMintError) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + name_: tuple.0, + symbol_: tuple.1, + _doMint: tuple.2, + _suppressMintError: tuple.3, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolConstructor for constructorCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Bool, + alloy::sol_types::sol_data::Bool, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.name_, + ), + ::tokenize( + &self.symbol_, + ), + ::tokenize( + &self._doMint, + ), + ::tokenize( + &self._suppressMintError, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: allowanceCall) -> Self { + (value.owner, value.spender) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for allowanceCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + owner: tuple.0, + spender: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: allowanceReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "allowance(address,address)"; + const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.owner, + ), + ::tokenize( + &self.spender, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: allowanceReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: approveCall) -> Self { + (value.spender, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for approveCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + spender: tuple.0, + amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: approveReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "approve(address,uint256)"; + const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.spender, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: approveReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: balanceOfCall) -> Self { + (value.account,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for balanceOfCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { account: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: balanceOfReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "balanceOf(address)"; + const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.account, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: balanceOfReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: decimalsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for decimalsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: decimalsReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for decimalsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for decimalsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = u8; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "decimals()"; + const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: decimalsReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: decreaseAllowanceCall) -> Self { + (value.spender, value.subtractedValue) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for decreaseAllowanceCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + spender: tuple.0, + subtractedValue: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: decreaseAllowanceReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)"; + const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.spender, + ), + as alloy_sol_types::SolType>::tokenize(&self.subtractedValue), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: decreaseAllowanceReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: increaseAllowanceCall) -> Self { + (value.spender, value.addedValue) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for increaseAllowanceCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + spender: tuple.0, + addedValue: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: increaseAllowanceReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "increaseAllowance(address,uint256)"; + const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.spender, + ), + as alloy_sol_types::SolType>::tokenize(&self.addedValue), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: increaseAllowanceReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `mint(uint256)` and selector `0xa0712d68`. +```solidity +function mint(uint256 mintAmount) external returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct mintCall { + #[allow(missing_docs)] + pub mintAmount: alloy::sol_types::private::primitives::aliases::U256, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`mint(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: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: mintCall) -> Self { + (value.mintAmount,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for mintCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { mintAmount: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: mintReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "mint(uint256)"; + const SELECTOR: [u8; 4] = [160u8, 113u8, 45u8, 104u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.mintAmount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: mintReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: nameCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for nameCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: nameReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for nameReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for nameCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::String; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "name()"; + const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: nameReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ownerCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ownerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ownerReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ownerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for ownerCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "owner()"; + const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: ownerReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `redeem(uint256)` and selector `0xdb006a75`. +```solidity +function redeem(uint256) external pure returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct redeemCall(pub alloy::sol_types::private::primitives::aliases::U256); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`redeem(uint256)`](redeemCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct redeemReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: redeemCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for redeemCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: redeemReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for redeemReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for redeemCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "redeem(uint256)"; + const SELECTOR: [u8; 4] = [219u8, 0u8, 106u8, 117u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.0), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: redeemReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: redeemReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: renounceOwnershipCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for renounceOwnershipCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: renounceOwnershipReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for renounceOwnershipReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl renounceOwnershipReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for renounceOwnershipCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = renounceOwnershipReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "renounceOwnership()"; + const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8]; + #[inline] + fn new<'a>( + tuple: 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 { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `sudoMint(address,uint256)` and selector `0x2d688ca8`. +```solidity +function sudoMint(address to, uint256 amount) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct sudoMintCall { + #[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 [`sudoMint(address,uint256)`](sudoMintCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct sudoMintReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: sudoMintCall) -> Self { + (value.to, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for sudoMintCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + to: tuple.0, + amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: sudoMintReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for sudoMintReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl sudoMintReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for sudoMintCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = sudoMintReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "sudoMint(address,uint256)"; + const SELECTOR: [u8; 4] = [45u8, 104u8, 140u8, 168u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.to, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + sudoMintReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: symbolCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for symbolCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: symbolReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for symbolReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for symbolCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::String; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "symbol()"; + const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: symbolReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: totalSupplyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for totalSupplyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: totalSupplyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for totalSupplyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for totalSupplyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "totalSupply()"; + const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: totalSupplyReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferCall) -> Self { + (value.to, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for transferCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + to: tuple.0, + amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transfer(address,uint256)"; + const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.to, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: transferReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferFromCall) -> Self { + (value.from, value.to, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for transferFromCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + from: tuple.0, + to: tuple.1, + amount: tuple.2, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferFromReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transferFrom(address,address,uint256)"; + const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.from, + ), + ::tokenize( + &self.to, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: transferFromReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: transferOwnershipCall) -> Self { + (value.newOwner,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for transferOwnershipCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { newOwner: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: transferOwnershipReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for transferOwnershipReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl transferOwnershipReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for transferOwnershipCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = transferOwnershipReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transferOwnership(address)"; + const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::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 { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + ///Container for all the [`DummyIonicToken`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum DummyIonicTokenCalls { + #[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)] + mint(mintCall), + #[allow(missing_docs)] + name(nameCall), + #[allow(missing_docs)] + owner(ownerCall), + #[allow(missing_docs)] + redeem(redeemCall), + #[allow(missing_docs)] + renounceOwnership(renounceOwnershipCall), + #[allow(missing_docs)] + sudoMint(sudoMintCall), + #[allow(missing_docs)] + symbol(symbolCall), + #[allow(missing_docs)] + totalSupply(totalSupplyCall), + #[allow(missing_docs)] + transfer(transferCall), + #[allow(missing_docs)] + transferFrom(transferFromCall), + #[allow(missing_docs)] + transferOwnership(transferOwnershipCall), + } + #[automatically_derived] + impl DummyIonicTokenCalls { + /// 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], + [45u8, 104u8, 140u8, 168u8], + [49u8, 60u8, 229u8, 103u8], + [57u8, 80u8, 147u8, 81u8], + [112u8, 160u8, 130u8, 49u8], + [113u8, 80u8, 24u8, 166u8], + [141u8, 165u8, 203u8, 91u8], + [149u8, 216u8, 155u8, 65u8], + [160u8, 113u8, 45u8, 104u8], + [164u8, 87u8, 194u8, 215u8], + [169u8, 5u8, 156u8, 187u8], + [219u8, 0u8, 106u8, 117u8], + [221u8, 98u8, 237u8, 62u8], + [242u8, 253u8, 227u8, 139u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for DummyIonicTokenCalls { + const NAME: &'static str = "DummyIonicTokenCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 17usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::allowance(_) => { + ::SELECTOR + } + Self::approve(_) => ::SELECTOR, + Self::balanceOf(_) => { + ::SELECTOR + } + Self::decimals(_) => ::SELECTOR, + Self::decreaseAllowance(_) => { + ::SELECTOR + } + Self::increaseAllowance(_) => { + ::SELECTOR + } + Self::mint(_) => ::SELECTOR, + Self::name(_) => ::SELECTOR, + Self::owner(_) => ::SELECTOR, + Self::redeem(_) => ::SELECTOR, + Self::renounceOwnership(_) => { + ::SELECTOR + } + Self::sudoMint(_) => ::SELECTOR, + Self::symbol(_) => ::SELECTOR, + Self::totalSupply(_) => { + ::SELECTOR + } + Self::transfer(_) => ::SELECTOR, + Self::transferFrom(_) => { + ::SELECTOR + } + Self::transferOwnership(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn name( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyIonicTokenCalls::name) + } + name + }, + { + fn approve( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyIonicTokenCalls::approve) + } + approve + }, + { + fn totalSupply( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummyIonicTokenCalls::totalSupply) + } + totalSupply + }, + { + fn transferFrom( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummyIonicTokenCalls::transferFrom) + } + transferFrom + }, + { + fn sudoMint( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyIonicTokenCalls::sudoMint) + } + sudoMint + }, + { + fn decimals( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyIonicTokenCalls::decimals) + } + decimals + }, + { + fn increaseAllowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummyIonicTokenCalls::increaseAllowance) + } + increaseAllowance + }, + { + fn balanceOf( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyIonicTokenCalls::balanceOf) + } + balanceOf + }, + { + fn renounceOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummyIonicTokenCalls::renounceOwnership) + } + renounceOwnership + }, + { + fn owner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyIonicTokenCalls::owner) + } + owner + }, + { + fn symbol( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyIonicTokenCalls::symbol) + } + symbol + }, + { + fn mint( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyIonicTokenCalls::mint) + } + mint + }, + { + fn decreaseAllowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummyIonicTokenCalls::decreaseAllowance) + } + decreaseAllowance + }, + { + fn transfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyIonicTokenCalls::transfer) + } + transfer + }, + { + fn redeem( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyIonicTokenCalls::redeem) + } + redeem + }, + { + fn allowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyIonicTokenCalls::allowance) + } + allowance + }, + { + fn transferOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummyIonicTokenCalls::transferOwnership) + } + transferOwnership + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn name( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyIonicTokenCalls::name) + } + name + }, + { + fn approve( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyIonicTokenCalls::approve) + } + approve + }, + { + fn totalSupply( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyIonicTokenCalls::totalSupply) + } + totalSupply + }, + { + fn transferFrom( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyIonicTokenCalls::transferFrom) + } + transferFrom + }, + { + fn sudoMint( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyIonicTokenCalls::sudoMint) + } + sudoMint + }, + { + fn decimals( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyIonicTokenCalls::decimals) + } + decimals + }, + { + fn increaseAllowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyIonicTokenCalls::increaseAllowance) + } + increaseAllowance + }, + { + fn balanceOf( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyIonicTokenCalls::balanceOf) + } + balanceOf + }, + { + fn renounceOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyIonicTokenCalls::renounceOwnership) + } + renounceOwnership + }, + { + fn owner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyIonicTokenCalls::owner) + } + owner + }, + { + fn symbol( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyIonicTokenCalls::symbol) + } + symbol + }, + { + fn mint( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyIonicTokenCalls::mint) + } + mint + }, + { + fn decreaseAllowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyIonicTokenCalls::decreaseAllowance) + } + decreaseAllowance + }, + { + fn transfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyIonicTokenCalls::transfer) + } + transfer + }, + { + fn redeem( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyIonicTokenCalls::redeem) + } + redeem + }, + { + fn allowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyIonicTokenCalls::allowance) + } + allowance + }, + { + fn transferOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyIonicTokenCalls::transferOwnership) + } + transferOwnership + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::allowance(inner) => { + ::abi_encoded_size(inner) + } + Self::approve(inner) => { + ::abi_encoded_size(inner) + } + Self::balanceOf(inner) => { + ::abi_encoded_size(inner) + } + Self::decimals(inner) => { + ::abi_encoded_size(inner) + } + Self::decreaseAllowance(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::increaseAllowance(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::mint(inner) => { + ::abi_encoded_size(inner) + } + Self::name(inner) => { + ::abi_encoded_size(inner) + } + Self::owner(inner) => { + ::abi_encoded_size(inner) + } + Self::redeem(inner) => { + ::abi_encoded_size(inner) + } + Self::renounceOwnership(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::sudoMint(inner) => { + ::abi_encoded_size(inner) + } + Self::symbol(inner) => { + ::abi_encoded_size(inner) + } + Self::totalSupply(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::transfer(inner) => { + ::abi_encoded_size(inner) + } + Self::transferFrom(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::transferOwnership(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::allowance(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::approve(inner) => { + ::abi_encode_raw(inner, out) + } + Self::balanceOf(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::decimals(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::decreaseAllowance(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::increaseAllowance(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::mint(inner) => { + ::abi_encode_raw(inner, out) + } + Self::name(inner) => { + ::abi_encode_raw(inner, out) + } + Self::owner(inner) => { + ::abi_encode_raw(inner, out) + } + Self::redeem(inner) => { + ::abi_encode_raw(inner, out) + } + Self::renounceOwnership(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::sudoMint(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::symbol(inner) => { + ::abi_encode_raw(inner, out) + } + Self::totalSupply(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transfer(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transferFrom(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transferOwnership(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`DummyIonicToken`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum DummyIonicTokenEvents { + #[allow(missing_docs)] + Approval(Approval), + #[allow(missing_docs)] + OwnershipTransferred(OwnershipTransferred), + #[allow(missing_docs)] + Transfer(Transfer), + } + #[automatically_derived] + impl DummyIonicTokenEvents { + /// 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]] = &[ + [ + 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, 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, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for DummyIonicTokenEvents { + const NAME: &'static str = "DummyIonicTokenEvents"; + const COUNT: usize = 3usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Approval) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::OwnershipTransferred) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Transfer) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 DummyIonicTokenEvents { + 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::OwnershipTransferred(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::OwnershipTransferred(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 as alloy_contract; + /**Creates a new wrapper around an on-chain [`DummyIonicToken`](self) contract instance. + +See the [wrapper's documentation](`DummyIonicTokenInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> DummyIonicTokenInstance { + DummyIonicTokenInstance::::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: alloy_contract::private::Network, + >( + provider: P, + name_: alloy::sol_types::private::String, + symbol_: alloy::sol_types::private::String, + _doMint: bool, + _suppressMintError: bool, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + DummyIonicTokenInstance::< + P, + N, + >::deploy(provider, name_, symbol_, _doMint, _suppressMintError) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + name_: alloy::sol_types::private::String, + symbol_: alloy::sol_types::private::String, + _doMint: bool, + _suppressMintError: bool, + ) -> alloy_contract::RawCallBuilder { + DummyIonicTokenInstance::< + P, + N, + >::deploy_builder(provider, name_, symbol_, _doMint, _suppressMintError) + } + /**A [`DummyIonicToken`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`DummyIonicToken`](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 DummyIonicTokenInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for DummyIonicTokenInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("DummyIonicTokenInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummyIonicTokenInstance { + /**Creates a new wrapper around an on-chain [`DummyIonicToken`](self) contract instance. + +See the [wrapper's documentation](`DummyIonicTokenInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + name_: alloy::sol_types::private::String, + symbol_: alloy::sol_types::private::String, + _doMint: bool, + _suppressMintError: bool, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder( + provider, + name_, + symbol_, + _doMint, + _suppressMintError, + ); + 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, + name_: alloy::sol_types::private::String, + symbol_: alloy::sol_types::private::String, + _doMint: bool, + _suppressMintError: bool, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + name_, + symbol_, + _doMint, + _suppressMintError, + }, + )[..], + ] + .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 DummyIonicTokenInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> DummyIonicTokenInstance { + DummyIonicTokenInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummyIonicTokenInstance { + /// 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( + &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 [`mint`] function. + pub fn mint( + &self, + mintAmount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> { + self.call_builder(&mintCall { mintAmount }) + } + ///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 [`redeem`] function. + pub fn redeem( + &self, + _0: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, redeemCall, N> { + self.call_builder(&redeemCall(_0)) + } + ///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 [`sudoMint`] function. + pub fn sudoMint( + &self, + to: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, sudoMintCall, N> { + self.call_builder(&sudoMintCall { to, amount }) + } + ///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, + 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, + }, + ) + } + ///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. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummyIonicTokenInstance { + /// 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( + &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::() + } + ///Creates a new event filter for the [`OwnershipTransferred`] event. + pub fn OwnershipTransferred_filter( + &self, + ) -> alloy_contract::Event<&P, OwnershipTransferred, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`Transfer`] event. + pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/dummy_pell_strategy.rs b/crates/bindings/src/dummy_pell_strategy.rs new file mode 100644 index 000000000..c65bf308c --- /dev/null +++ b/crates/bindings/src/dummy_pell_strategy.rs @@ -0,0 +1,218 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface DummyPellStrategy {} +``` + +...which was generated by the following JSON ABI: +```json +[] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod DummyPellStrategy { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x6080604052348015600e575f5ffd5b50603e80601a5f395ff3fe60806040525f5ffdfea264697066735822122045f7292c77568df36e723757ab30c5367b3fb087c1497d4353e1d25d621982cc64736f6c634300081c0033 + /// ``` + #[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`>\x80`\x1A_9_\xF3\xFE`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 E\xF7),wV\x8D\xF3nr7W\xAB0\xC56{?\xB0\x87\xC1I}CS\xE1\xD2]b\x19\x82\xCCdsolcC\0\x08\x1C\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x60806040525f5ffdfea264697066735822122045f7292c77568df36e723757ab30c5367b3fb087c1497d4353e1d25d621982cc64736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 E\xF7),wV\x8D\xF3nr7W\xAB0\xC56{?\xB0\x87\xC1I}CS\xE1\xD2]b\x19\x82\xCCdsolcC\0\x08\x1C\x003", + ); + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`DummyPellStrategy`](self) contract instance. + +See the [wrapper's documentation](`DummyPellStrategyInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> DummyPellStrategyInstance { + DummyPellStrategyInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + DummyPellStrategyInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + DummyPellStrategyInstance::::deploy_builder(provider) + } + /**A [`DummyPellStrategy`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`DummyPellStrategy`](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 DummyPellStrategyInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for DummyPellStrategyInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("DummyPellStrategyInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummyPellStrategyInstance { + /**Creates a new wrapper around an on-chain [`DummyPellStrategy`](self) contract instance. + +See the [wrapper's documentation](`DummyPellStrategyInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 DummyPellStrategyInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> DummyPellStrategyInstance { + DummyPellStrategyInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummyPellStrategyInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummyPellStrategyInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/dummy_pell_strategy_manager.rs b/crates/bindings/src/dummy_pell_strategy_manager.rs new file mode 100644 index 000000000..2b90110f2 --- /dev/null +++ b/crates/bindings/src/dummy_pell_strategy_manager.rs @@ -0,0 +1,838 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface DummyPellStrategyManager { + function depositIntoStrategyWithStaker(address, address, address, uint256 amount) external pure returns (uint256 shares); + function stakerStrategyShares(address, address) external pure returns (uint256); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "depositIntoStrategyWithStaker", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + }, + { + "name": "", + "type": "address", + "internalType": "contract IPellStrategy" + }, + { + "name": "", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "shares", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "stakerStrategyShares", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + }, + { + "name": "", + "type": "address", + "internalType": "contract IPellStrategy" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + } +] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod DummyPellStrategyManager { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x6080604052348015600e575f5ffd5b506101538061001c5f395ff3fe608060405234801561000f575f5ffd5b5060043610610034575f3560e01c80637a7e0d9214610038578063e46842b71461005f575b5f5ffd5b61004d610046366004610098565b5f92915050565b60405190815260200160405180910390f35b61004d61006d3660046100cf565b9392505050565b73ffffffffffffffffffffffffffffffffffffffff81168114610095575f5ffd5b50565b5f5f604083850312156100a9575f5ffd5b82356100b481610074565b915060208301356100c481610074565b809150509250929050565b5f5f5f5f608085870312156100e2575f5ffd5b84356100ed81610074565b935060208501356100fd81610074565b9250604085013561010d81610074565b939692955092936060013592505056fea2646970667358221220e239b4156f962c3bf171057532c3c6d8605e9b8f555a1035740ad3627dd8d4b764736f6c634300081c0033 + /// ``` + #[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\x01S\x80a\0\x1C_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x004W_5`\xE0\x1C\x80cz~\r\x92\x14a\08W\x80c\xE4hB\xB7\x14a\0_W[__\xFD[a\0Ma\0F6`\x04a\0\x98V[_\x92\x91PPV[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[a\0Ma\0m6`\x04a\0\xCFV[\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\0\x95W__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0\xA9W__\xFD[\x825a\0\xB4\x81a\0tV[\x91P` \x83\x015a\0\xC4\x81a\0tV[\x80\x91PP\x92P\x92\x90PV[____`\x80\x85\x87\x03\x12\x15a\0\xE2W__\xFD[\x845a\0\xED\x81a\0tV[\x93P` \x85\x015a\0\xFD\x81a\0tV[\x92P`@\x85\x015a\x01\r\x81a\0tV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV\xFE\xA2dipfsX\"\x12 \xE29\xB4\x15o\x96,;\xF1q\x05u2\xC3\xC6\xD8`^\x9B\x8FUZ\x105t\n\xD3b}\xD8\xD4\xB7dsolcC\0\x08\x1C\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x608060405234801561000f575f5ffd5b5060043610610034575f3560e01c80637a7e0d9214610038578063e46842b71461005f575b5f5ffd5b61004d610046366004610098565b5f92915050565b60405190815260200160405180910390f35b61004d61006d3660046100cf565b9392505050565b73ffffffffffffffffffffffffffffffffffffffff81168114610095575f5ffd5b50565b5f5f604083850312156100a9575f5ffd5b82356100b481610074565b915060208301356100c481610074565b809150509250929050565b5f5f5f5f608085870312156100e2575f5ffd5b84356100ed81610074565b935060208501356100fd81610074565b9250604085013561010d81610074565b939692955092936060013592505056fea2646970667358221220e239b4156f962c3bf171057532c3c6d8605e9b8f555a1035740ad3627dd8d4b764736f6c634300081c0033 + /// ``` + #[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\x80cz~\r\x92\x14a\08W\x80c\xE4hB\xB7\x14a\0_W[__\xFD[a\0Ma\0F6`\x04a\0\x98V[_\x92\x91PPV[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[a\0Ma\0m6`\x04a\0\xCFV[\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\0\x95W__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0\xA9W__\xFD[\x825a\0\xB4\x81a\0tV[\x91P` \x83\x015a\0\xC4\x81a\0tV[\x80\x91PP\x92P\x92\x90PV[____`\x80\x85\x87\x03\x12\x15a\0\xE2W__\xFD[\x845a\0\xED\x81a\0tV[\x93P` \x85\x015a\0\xFD\x81a\0tV[\x92P`@\x85\x015a\x01\r\x81a\0tV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV\xFE\xA2dipfsX\"\x12 \xE29\xB4\x15o\x96,;\xF1q\x05u2\xC3\xC6\xD8`^\x9B\x8FUZ\x105t\n\xD3b}\xD8\xD4\xB7dsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `depositIntoStrategyWithStaker(address,address,address,uint256)` and selector `0xe46842b7`. +```solidity +function depositIntoStrategyWithStaker(address, address, address, uint256 amount) external pure returns (uint256 shares); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct depositIntoStrategyWithStakerCall { + #[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 amount: alloy::sol_types::private::primitives::aliases::U256, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`depositIntoStrategyWithStaker(address,address,address,uint256)`](depositIntoStrategyWithStakerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct depositIntoStrategyWithStakerReturn { + #[allow(missing_docs)] + pub shares: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: depositIntoStrategyWithStakerCall) -> Self { + (value._0, value._1, value._2, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for depositIntoStrategyWithStakerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _0: tuple.0, + _1: tuple.1, + _2: tuple.2, + amount: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: depositIntoStrategyWithStakerReturn) -> Self { + (value.shares,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for depositIntoStrategyWithStakerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { shares: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for depositIntoStrategyWithStakerCall { + 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "depositIntoStrategyWithStaker(address,address,address,uint256)"; + const SELECTOR: [u8; 4] = [228u8, 104u8, 66u8, 183u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._0, + ), + ::tokenize( + &self._1, + ), + ::tokenize( + &self._2, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: depositIntoStrategyWithStakerReturn = r.into(); + r.shares + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: depositIntoStrategyWithStakerReturn = r.into(); + r.shares + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `stakerStrategyShares(address,address)` and selector `0x7a7e0d92`. +```solidity +function stakerStrategyShares(address, address) external pure returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct stakerStrategySharesCall { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _1: alloy::sol_types::private::Address, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`stakerStrategyShares(address,address)`](stakerStrategySharesCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct stakerStrategySharesReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: stakerStrategySharesCall) -> Self { + (value._0, value._1) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for stakerStrategySharesCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0, _1: tuple.1 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: stakerStrategySharesReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for stakerStrategySharesReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for stakerStrategySharesCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "stakerStrategyShares(address,address)"; + const SELECTOR: [u8; 4] = [122u8, 126u8, 13u8, 146u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._0, + ), + ::tokenize( + &self._1, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: stakerStrategySharesReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: stakerStrategySharesReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`DummyPellStrategyManager`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum DummyPellStrategyManagerCalls { + #[allow(missing_docs)] + depositIntoStrategyWithStaker(depositIntoStrategyWithStakerCall), + #[allow(missing_docs)] + stakerStrategyShares(stakerStrategySharesCall), + } + #[automatically_derived] + impl DummyPellStrategyManagerCalls { + /// 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]] = &[ + [122u8, 126u8, 13u8, 146u8], + [228u8, 104u8, 66u8, 183u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for DummyPellStrategyManagerCalls { + const NAME: &'static str = "DummyPellStrategyManagerCalls"; + const MIN_DATA_LENGTH: usize = 64usize; + const COUNT: usize = 2usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::depositIntoStrategyWithStaker(_) => { + ::SELECTOR + } + Self::stakerStrategyShares(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn stakerStrategyShares( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummyPellStrategyManagerCalls::stakerStrategyShares) + } + stakerStrategyShares + }, + { + fn depositIntoStrategyWithStaker( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + DummyPellStrategyManagerCalls::depositIntoStrategyWithStaker, + ) + } + depositIntoStrategyWithStaker + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn stakerStrategyShares( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyPellStrategyManagerCalls::stakerStrategyShares) + } + stakerStrategyShares + }, + { + fn depositIntoStrategyWithStaker( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + DummyPellStrategyManagerCalls::depositIntoStrategyWithStaker, + ) + } + depositIntoStrategyWithStaker + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::depositIntoStrategyWithStaker(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::stakerStrategyShares(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::depositIntoStrategyWithStaker(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::stakerStrategyShares(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`DummyPellStrategyManager`](self) contract instance. + +See the [wrapper's documentation](`DummyPellStrategyManagerInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> DummyPellStrategyManagerInstance { + DummyPellStrategyManagerInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + DummyPellStrategyManagerInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + DummyPellStrategyManagerInstance::::deploy_builder(provider) + } + /**A [`DummyPellStrategyManager`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`DummyPellStrategyManager`](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 DummyPellStrategyManagerInstance< + P, + N = alloy_contract::private::Ethereum, + > { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for DummyPellStrategyManagerInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("DummyPellStrategyManagerInstance") + .field(&self.address) + .finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummyPellStrategyManagerInstance { + /**Creates a new wrapper around an on-chain [`DummyPellStrategyManager`](self) contract instance. + +See the [wrapper's documentation](`DummyPellStrategyManagerInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 DummyPellStrategyManagerInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> DummyPellStrategyManagerInstance { + DummyPellStrategyManagerInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummyPellStrategyManagerInstance { + /// 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( + &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 [`depositIntoStrategyWithStaker`] function. + pub fn depositIntoStrategyWithStaker( + &self, + _0: alloy::sol_types::private::Address, + _1: alloy::sol_types::private::Address, + _2: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, depositIntoStrategyWithStakerCall, N> { + self.call_builder( + &depositIntoStrategyWithStakerCall { + _0, + _1, + _2, + amount, + }, + ) + } + ///Creates a new call builder for the [`stakerStrategyShares`] function. + pub fn stakerStrategyShares( + &self, + _0: alloy::sol_types::private::Address, + _1: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, stakerStrategySharesCall, N> { + self.call_builder(&stakerStrategySharesCall { _0, _1 }) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummyPellStrategyManagerInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/dummy_se_bep20.rs b/crates/bindings/src/dummy_se_bep20.rs new file mode 100644 index 000000000..9feeef8ba --- /dev/null +++ b/crates/bindings/src/dummy_se_bep20.rs @@ -0,0 +1,5161 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface DummySeBep20 { + event Approval(address indexed owner, address indexed spender, uint256 value); + event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); + event Transfer(address indexed from, address indexed to, uint256 value); + + constructor(string name_, string symbol_, bool _doMint, bool _suppressMintError); + + 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 balanceOfUnderlying(address) external pure 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 mint(uint256) external pure returns (uint256); + function mintBehalf(address receiver, uint256 mintAmount) external returns (uint256); + function name() external view returns (string memory); + function owner() external view returns (address); + function redeem(uint256) external pure returns (uint256); + function renounceOwnership() external; + function sudoMint(address to, uint256 amount) external; + function symbol() external view returns (string memory); + function totalSupply() external view returns (uint256); + function transfer(address to, uint256 amount) external returns (bool); + function transferFrom(address from, address to, uint256 amount) external returns (bool); + function transferOwnership(address newOwner) external; +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "name_", + "type": "string", + "internalType": "string" + }, + { + "name": "symbol_", + "type": "string", + "internalType": "string" + }, + { + "name": "_doMint", + "type": "bool", + "internalType": "bool" + }, + { + "name": "_suppressMintError", + "type": "bool", + "internalType": "bool" + } + ], + "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": "balanceOfUnderlying", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "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": "mint", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "mintBehalf", + "inputs": [ + { + "name": "receiver", + "type": "address", + "internalType": "address" + }, + { + "name": "mintAmount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "name", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "owner", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "redeem", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "renounceOwnership", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "sudoMint", + "inputs": [ + { + "name": "to", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "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": "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" + }, + { + "type": "function", + "name": "transferOwnership", + "inputs": [ + { + "name": "newOwner", + "type": "address", + "internalType": "address" + } + ], + "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": "OwnershipTransferred", + "inputs": [ + { + "name": "previousOwner", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "newOwner", + "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 DummySeBep20 { + use super::*; + use alloy::sol_types as 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__\xFD[P`@Qa\x11\x988\x03\x80a\x11\x98\x839\x81\x01`@\x81\x90Ra\0.\x91a\x01\xA2V[\x83\x83`\x03a\0<\x83\x82a\x02\xABV[P`\x04a\0I\x82\x82a\x02\xABV[PPPa\0ba\0]a\0\x9C` \x1B` \x1CV[a\0\xA0V[`\x05\x80Ta\xFF\xFF`\xA0\x1B\x19\x16`\x01`\xA0\x1B\x93\x15\x15\x93\x90\x93\x02`\xFF`\xA8\x1B\x19\x16\x92\x90\x92\x17`\x01`\xA8\x1B\x91\x15\x15\x91\x90\x91\x02\x17\x90UPa\x03e\x90PV[3\x90V[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x01`\x01`\xA0\x1B\x03\x19\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x82`\x1F\x83\x01\x12a\x01\x14W__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01-Wa\x01-a\0\xF1V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x01[Wa\x01[a\0\xF1V[`@R\x81\x81R\x83\x82\x01` \x01\x85\x10\x15a\x01rW__\xFD[\x81` \x85\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[\x80Q\x80\x15\x15\x81\x14a\x01\x9DW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x01\xB5W__\xFD[\x84Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\xCAW__\xFD[a\x01\xD6\x87\x82\x88\x01a\x01\x05V[` \x87\x01Q\x90\x95P\x90P`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\xF3W__\xFD[a\x01\xFF\x87\x82\x88\x01a\x01\x05V[\x93PPa\x02\x0E`@\x86\x01a\x01\x8EV[\x91Pa\x02\x1C``\x86\x01a\x01\x8EV[\x90P\x92\x95\x91\x94P\x92PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x02;W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x02YWcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\x02\xA6W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x02\x84WP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x02\xA3W_\x81U`\x01\x01a\x02\x90V[PP[PPPV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x02\xC4Wa\x02\xC4a\0\xF1V[a\x02\xD8\x81a\x02\xD2\x84Ta\x02'V[\x84a\x02_V[` `\x1F\x82\x11`\x01\x81\x14a\x03\nW_\x83\x15a\x02\xF3WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x02\xA3V[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x039W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x03\x19V[P\x84\x82\x10\x15a\x03VW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[a\x0E&\x80a\x03r_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01IW_5`\xE0\x1C\x80cp\xA0\x821\x11a\0\xC7W\x80c\xA4W\xC2\xD7\x11a\0}W\x80c\xDB\0ju\x11a\0cW\x80c\xDB\0ju\x14a\x02cW\x80c\xDDb\xED>\x14a\x02\x97W\x80c\xF2\xFD\xE3\x8B\x14a\x02\xCFW__\xFD[\x80c\xA4W\xC2\xD7\x14a\x02qW\x80c\xA9\x05\x9C\xBB\x14a\x02\x84W__\xFD[\x80c\x8D\xA5\xCB[\x11a\0\xADW\x80c\x8D\xA5\xCB[\x14a\x02@W\x80c\x95\xD8\x9BA\x14a\x02[W\x80c\xA0q-h\x14a\x02cW__\xFD[\x80cp\xA0\x821\x14a\x02\x10W\x80cqP\x18\xA6\x14a\x028W__\xFD[\x80c#\xB8r\xDD\x11a\x01\x1CW\x80c1<\xE5g\x11a\x01\x02W\x80c1<\xE5g\x14a\x01\xDBW\x80c9P\x93Q\x14a\x01\xEAW\x80c:\xF9\xE6i\x14a\x01\xFDW__\xFD[\x80c#\xB8r\xDD\x14a\x01\xB3W\x80c-h\x8C\xA8\x14a\x01\xC6W__\xFD[\x80c\x06\xFD\xDE\x03\x14a\x01MW\x80c\t^\xA7\xB3\x14a\x01kW\x80c\x18\x16\r\xDD\x14a\x01\x8EW\x80c#2>\x03\x14a\x01\xA0W[__\xFD[a\x01Ua\x02\xE2V[`@Qa\x01b\x91\x90a\x0C/V[`@Q\x80\x91\x03\x90\xF3[a\x01~a\x01y6`\x04a\x0C\x9DV[a\x03rV[`@Q\x90\x15\x15\x81R` \x01a\x01bV[`\x02T[`@Q\x90\x81R` \x01a\x01bV[a\x01\x92a\x01\xAE6`\x04a\x0C\x9DV[a\x03\x8BV[a\x01~a\x01\xC16`\x04a\x0C\xC5V[a\x03\xF5V[a\x01\xD9a\x01\xD46`\x04a\x0C\x9DV[a\x04\x18V[\0[`@Q`\x12\x81R` \x01a\x01bV[a\x01~a\x01\xF86`\x04a\x0C\x9DV[a\x04\x85V[a\x01\x92a\x02\x0B6`\x04a\x0C\xFFV[P_\x90V[a\x01\x92a\x02\x1E6`\x04a\x0C\xFFV[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R` \x81\x90R`@\x90 T\x90V[a\x01\xD9a\x04\xC3V[`\x05T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01bV[a\x01Ua\x05(V[a\x01\x92a\x02\x0B6`\x04a\r\x1FV[a\x01~a\x02\x7F6`\x04a\x0C\x9DV[a\x057V[a\x01~a\x02\x926`\x04a\x0C\x9DV[a\x05\xE0V[a\x01\x92a\x02\xA56`\x04a\r6V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[a\x01\xD9a\x02\xDD6`\x04a\x0C\xFFV[a\x05\xEDV[```\x03\x80Ta\x02\xF1\x90a\rgV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\x1D\x90a\rgV[\x80\x15a\x03hW\x80`\x1F\x10a\x03?Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03hV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03KW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[_3a\x03\x7F\x81\x85\x85a\x06\xCFV[`\x01\x91PP[\x92\x91PPV[`\x05T_\x90u\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x03\xB8WP_a\x03\x85V[`\x05Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x03\xECWa\x03\xE5\x83\x83a\x08&V[P_a\x03\x85V[P`\x01\x92\x91PPV[_3a\x04\x02\x85\x82\x85a\t\x02V[a\x04\r\x85\x85\x85a\t\xB1V[P`\x01\x94\x93PPPPV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x04wW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x04\x81\x82\x82a\x08&V[PPV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90a\x03\x7F\x90\x82\x90\x86\x90a\x04\xBE\x90\x87\x90a\r\xB8V[a\x06\xCFV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x05\x1DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04nV[a\x05&_a\x0B\xC6V[V[```\x04\x80Ta\x02\xF1\x90a\rgV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90\x83\x81\x10\x15a\x05\xD3W`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[a\x04\r\x82\x86\x86\x84\x03a\x06\xCFV[_3a\x03\x7F\x81\x85\x85a\t\xB1V[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x06GW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04nV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x06\xC3W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01R\x7Fddress\0\0\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\x04nV[a\x06\xCC\x81a\x0B\xC6V[PV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x07JW`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x07\xC6W`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\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[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x08|W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FERC20: mint to the zero address\0`D\x82\x01R`d\x01a\x04nV[\x80`\x02_\x82\x82Ta\x08\x8D\x91\x90a\r\xB8V[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x83\x92\x90a\x08\xB9\x90\x84\x90a\r\xB8V[\x90\x91UPP`@Q\x81\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90_\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[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R 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\x81\x14a\t\xABW\x81\x81\x10\x15a\t\x9EW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FERC20: insufficient allowance\0\0\0`D\x82\x01R`d\x01a\x04nV[a\t\xAB\x84\x84\x84\x84\x03a\x06\xCFV[PPPPV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\n-W`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\n\xA9W`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R` \x81\x90R`@\x90 T\x81\x81\x10\x15a\x0B7W`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16_\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R\x90\x81 \x80T\x84\x92\x90a\x0Bm\x90\x84\x90a\r\xB8V[\x92PP\x81\x90UP\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\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\x0B\xB9\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3a\t\xABV[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\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\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\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\x84\x01\x01\x91PP\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0C\x98W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0C\xAEW__\xFD[a\x0C\xB7\x83a\x0C\x82V[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x0C\xD7W__\xFD[a\x0C\xE0\x84a\x0C\x82V[\x92Pa\x0C\xEE` \x85\x01a\x0C\x82V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\r\x0FW__\xFD[a\r\x18\x82a\x0C\x82V[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\r/W__\xFD[P5\x91\x90PV[__`@\x83\x85\x03\x12\x15a\rGW__\xFD[a\rP\x83a\x0C\x82V[\x91Pa\r^` \x84\x01a\x0C\x82V[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\r{W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\r\xB2W\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[P\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x03\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\xFE\xA2dipfsX\"\x12 ,O\x84\x9FL\x9E\x11!\n*\x99\xA0\x9C\xAA\x87\xD3\x9A\x93\xB9+\xE3\xD1\xD3\xB7\xA0\x8B\xF4(\x94\xEB\xE0'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\x01IW_5`\xE0\x1C\x80cp\xA0\x821\x11a\0\xC7W\x80c\xA4W\xC2\xD7\x11a\0}W\x80c\xDB\0ju\x11a\0cW\x80c\xDB\0ju\x14a\x02cW\x80c\xDDb\xED>\x14a\x02\x97W\x80c\xF2\xFD\xE3\x8B\x14a\x02\xCFW__\xFD[\x80c\xA4W\xC2\xD7\x14a\x02qW\x80c\xA9\x05\x9C\xBB\x14a\x02\x84W__\xFD[\x80c\x8D\xA5\xCB[\x11a\0\xADW\x80c\x8D\xA5\xCB[\x14a\x02@W\x80c\x95\xD8\x9BA\x14a\x02[W\x80c\xA0q-h\x14a\x02cW__\xFD[\x80cp\xA0\x821\x14a\x02\x10W\x80cqP\x18\xA6\x14a\x028W__\xFD[\x80c#\xB8r\xDD\x11a\x01\x1CW\x80c1<\xE5g\x11a\x01\x02W\x80c1<\xE5g\x14a\x01\xDBW\x80c9P\x93Q\x14a\x01\xEAW\x80c:\xF9\xE6i\x14a\x01\xFDW__\xFD[\x80c#\xB8r\xDD\x14a\x01\xB3W\x80c-h\x8C\xA8\x14a\x01\xC6W__\xFD[\x80c\x06\xFD\xDE\x03\x14a\x01MW\x80c\t^\xA7\xB3\x14a\x01kW\x80c\x18\x16\r\xDD\x14a\x01\x8EW\x80c#2>\x03\x14a\x01\xA0W[__\xFD[a\x01Ua\x02\xE2V[`@Qa\x01b\x91\x90a\x0C/V[`@Q\x80\x91\x03\x90\xF3[a\x01~a\x01y6`\x04a\x0C\x9DV[a\x03rV[`@Q\x90\x15\x15\x81R` \x01a\x01bV[`\x02T[`@Q\x90\x81R` \x01a\x01bV[a\x01\x92a\x01\xAE6`\x04a\x0C\x9DV[a\x03\x8BV[a\x01~a\x01\xC16`\x04a\x0C\xC5V[a\x03\xF5V[a\x01\xD9a\x01\xD46`\x04a\x0C\x9DV[a\x04\x18V[\0[`@Q`\x12\x81R` \x01a\x01bV[a\x01~a\x01\xF86`\x04a\x0C\x9DV[a\x04\x85V[a\x01\x92a\x02\x0B6`\x04a\x0C\xFFV[P_\x90V[a\x01\x92a\x02\x1E6`\x04a\x0C\xFFV[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R` \x81\x90R`@\x90 T\x90V[a\x01\xD9a\x04\xC3V[`\x05T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01bV[a\x01Ua\x05(V[a\x01\x92a\x02\x0B6`\x04a\r\x1FV[a\x01~a\x02\x7F6`\x04a\x0C\x9DV[a\x057V[a\x01~a\x02\x926`\x04a\x0C\x9DV[a\x05\xE0V[a\x01\x92a\x02\xA56`\x04a\r6V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[a\x01\xD9a\x02\xDD6`\x04a\x0C\xFFV[a\x05\xEDV[```\x03\x80Ta\x02\xF1\x90a\rgV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\x1D\x90a\rgV[\x80\x15a\x03hW\x80`\x1F\x10a\x03?Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03hV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03KW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[_3a\x03\x7F\x81\x85\x85a\x06\xCFV[`\x01\x91PP[\x92\x91PPV[`\x05T_\x90u\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x03\xB8WP_a\x03\x85V[`\x05Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x03\xECWa\x03\xE5\x83\x83a\x08&V[P_a\x03\x85V[P`\x01\x92\x91PPV[_3a\x04\x02\x85\x82\x85a\t\x02V[a\x04\r\x85\x85\x85a\t\xB1V[P`\x01\x94\x93PPPPV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x04wW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x04\x81\x82\x82a\x08&V[PPV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90a\x03\x7F\x90\x82\x90\x86\x90a\x04\xBE\x90\x87\x90a\r\xB8V[a\x06\xCFV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x05\x1DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04nV[a\x05&_a\x0B\xC6V[V[```\x04\x80Ta\x02\xF1\x90a\rgV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90\x83\x81\x10\x15a\x05\xD3W`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[a\x04\r\x82\x86\x86\x84\x03a\x06\xCFV[_3a\x03\x7F\x81\x85\x85a\t\xB1V[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x06GW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04nV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x06\xC3W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01R\x7Fddress\0\0\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\x04nV[a\x06\xCC\x81a\x0B\xC6V[PV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x07JW`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x07\xC6W`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\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[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x08|W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FERC20: mint to the zero address\0`D\x82\x01R`d\x01a\x04nV[\x80`\x02_\x82\x82Ta\x08\x8D\x91\x90a\r\xB8V[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x83\x92\x90a\x08\xB9\x90\x84\x90a\r\xB8V[\x90\x91UPP`@Q\x81\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90_\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[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R 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\x81\x14a\t\xABW\x81\x81\x10\x15a\t\x9EW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FERC20: insufficient allowance\0\0\0`D\x82\x01R`d\x01a\x04nV[a\t\xAB\x84\x84\x84\x84\x03a\x06\xCFV[PPPPV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\n-W`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\n\xA9W`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R` \x81\x90R`@\x90 T\x81\x81\x10\x15a\x0B7W`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16_\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R\x90\x81 \x80T\x84\x92\x90a\x0Bm\x90\x84\x90a\r\xB8V[\x92PP\x81\x90UP\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\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\x0B\xB9\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3a\t\xABV[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\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\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\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\x84\x01\x01\x91PP\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0C\x98W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0C\xAEW__\xFD[a\x0C\xB7\x83a\x0C\x82V[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x0C\xD7W__\xFD[a\x0C\xE0\x84a\x0C\x82V[\x92Pa\x0C\xEE` \x85\x01a\x0C\x82V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\r\x0FW__\xFD[a\r\x18\x82a\x0C\x82V[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\r/W__\xFD[P5\x91\x90PV[__`@\x83\x85\x03\x12\x15a\rGW__\xFD[a\rP\x83a\x0C\x82V[\x91Pa\r^` \x84\x01a\x0C\x82V[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\r{W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\r\xB2W\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[P\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x03\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\xFE\xA2dipfsX\"\x12 ,O\x84\x9FL\x9E\x11!\n*\x99\xA0\x9C\xAA\x87\xD3\x9A\x93\xB9+\xE3\xD1\xD3\xB7\xA0\x8B\xF4(\x94\xEB\xE0'dsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Approval { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + 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, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + owner: topics.1, + spender: topics.2, + value: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.value), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.owner, + ); + out[2usize] = ::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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for OwnershipTransferred { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + 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, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + previousOwner: topics.1, + newOwner: topics.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return 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) -> ::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() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.previousOwner, + ); + out[2usize] = ::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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Transfer { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + 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, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + from: topics.1, + to: topics.2, + value: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.value), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.from, + ); + out[2usize] = ::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_, bool _doMint, bool _suppressMintError); +```*/ + #[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, + #[allow(missing_docs)] + pub _doMint: bool, + #[allow(missing_docs)] + pub _suppressMintError: bool, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Bool, + alloy::sol_types::sol_data::Bool, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::String, + alloy::sol_types::private::String, + bool, + bool, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value.name_, value.symbol_, value._doMint, value._suppressMintError) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + name_: tuple.0, + symbol_: tuple.1, + _doMint: tuple.2, + _suppressMintError: tuple.3, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolConstructor for constructorCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Bool, + alloy::sol_types::sol_data::Bool, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.name_, + ), + ::tokenize( + &self.symbol_, + ), + ::tokenize( + &self._doMint, + ), + ::tokenize( + &self._suppressMintError, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: allowanceCall) -> Self { + (value.owner, value.spender) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for allowanceCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + owner: tuple.0, + spender: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: allowanceReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "allowance(address,address)"; + const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.owner, + ), + ::tokenize( + &self.spender, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: allowanceReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: approveCall) -> Self { + (value.spender, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for approveCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + spender: tuple.0, + amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: approveReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "approve(address,uint256)"; + const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.spender, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: approveReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: balanceOfCall) -> Self { + (value.account,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for balanceOfCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { account: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: balanceOfReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "balanceOf(address)"; + const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.account, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: balanceOfReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `balanceOfUnderlying(address)` and selector `0x3af9e669`. +```solidity +function balanceOfUnderlying(address) external pure returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct balanceOfUnderlyingCall(pub alloy::sol_types::private::Address); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`balanceOfUnderlying(address)`](balanceOfUnderlyingCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct balanceOfUnderlyingReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: balanceOfUnderlyingCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for balanceOfUnderlyingCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: balanceOfUnderlyingReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for balanceOfUnderlyingReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for balanceOfUnderlyingCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "balanceOfUnderlying(address)"; + const SELECTOR: [u8; 4] = [58u8, 249u8, 230u8, 105u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.0, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: balanceOfUnderlyingReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: balanceOfUnderlyingReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: decimalsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for decimalsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: decimalsReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for decimalsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for decimalsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = u8; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "decimals()"; + const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: decimalsReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: decreaseAllowanceCall) -> Self { + (value.spender, value.subtractedValue) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for decreaseAllowanceCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + spender: tuple.0, + subtractedValue: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: decreaseAllowanceReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)"; + const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.spender, + ), + as alloy_sol_types::SolType>::tokenize(&self.subtractedValue), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: decreaseAllowanceReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: increaseAllowanceCall) -> Self { + (value.spender, value.addedValue) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for increaseAllowanceCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + spender: tuple.0, + addedValue: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: increaseAllowanceReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "increaseAllowance(address,uint256)"; + const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.spender, + ), + as alloy_sol_types::SolType>::tokenize(&self.addedValue), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: increaseAllowanceReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `mint(uint256)` and selector `0xa0712d68`. +```solidity +function mint(uint256) external pure returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct mintCall(pub alloy::sol_types::private::primitives::aliases::U256); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`mint(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: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: mintCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for mintCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: mintReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "mint(uint256)"; + const SELECTOR: [u8; 4] = [160u8, 113u8, 45u8, 104u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.0), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: mintReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `mintBehalf(address,uint256)` and selector `0x23323e03`. +```solidity +function mintBehalf(address receiver, uint256 mintAmount) external returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct mintBehalfCall { + #[allow(missing_docs)] + pub receiver: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub mintAmount: alloy::sol_types::private::primitives::aliases::U256, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`mintBehalf(address,uint256)`](mintBehalfCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct mintBehalfReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: mintBehalfCall) -> Self { + (value.receiver, value.mintAmount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for mintBehalfCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + receiver: tuple.0, + mintAmount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: mintBehalfReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for mintBehalfReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for mintBehalfCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "mintBehalf(address,uint256)"; + const SELECTOR: [u8; 4] = [35u8, 50u8, 62u8, 3u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.receiver, + ), + as alloy_sol_types::SolType>::tokenize(&self.mintAmount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: mintBehalfReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: mintBehalfReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: nameCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for nameCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: nameReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for nameReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for nameCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::String; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "name()"; + const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: nameReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ownerCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ownerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ownerReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ownerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for ownerCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "owner()"; + const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: ownerReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `redeem(uint256)` and selector `0xdb006a75`. +```solidity +function redeem(uint256) external pure returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct redeemCall(pub alloy::sol_types::private::primitives::aliases::U256); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`redeem(uint256)`](redeemCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct redeemReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: redeemCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for redeemCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: redeemReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for redeemReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for redeemCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "redeem(uint256)"; + const SELECTOR: [u8; 4] = [219u8, 0u8, 106u8, 117u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.0), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: redeemReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: redeemReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: renounceOwnershipCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for renounceOwnershipCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: renounceOwnershipReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for renounceOwnershipReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl renounceOwnershipReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for renounceOwnershipCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = renounceOwnershipReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "renounceOwnership()"; + const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8]; + #[inline] + fn new<'a>( + tuple: 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 { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `sudoMint(address,uint256)` and selector `0x2d688ca8`. +```solidity +function sudoMint(address to, uint256 amount) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct sudoMintCall { + #[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 [`sudoMint(address,uint256)`](sudoMintCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct sudoMintReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: sudoMintCall) -> Self { + (value.to, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for sudoMintCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + to: tuple.0, + amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: sudoMintReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for sudoMintReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl sudoMintReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for sudoMintCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = sudoMintReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "sudoMint(address,uint256)"; + const SELECTOR: [u8; 4] = [45u8, 104u8, 140u8, 168u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.to, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + sudoMintReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: symbolCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for symbolCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: symbolReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for symbolReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for symbolCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::String; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "symbol()"; + const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: symbolReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: totalSupplyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for totalSupplyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: totalSupplyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for totalSupplyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for totalSupplyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "totalSupply()"; + const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: totalSupplyReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferCall) -> Self { + (value.to, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for transferCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + to: tuple.0, + amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transfer(address,uint256)"; + const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.to, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: transferReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferFromCall) -> Self { + (value.from, value.to, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for transferFromCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + from: tuple.0, + to: tuple.1, + amount: tuple.2, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferFromReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transferFrom(address,address,uint256)"; + const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.from, + ), + ::tokenize( + &self.to, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: transferFromReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: transferOwnershipCall) -> Self { + (value.newOwner,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for transferOwnershipCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { newOwner: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: transferOwnershipReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for transferOwnershipReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl transferOwnershipReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for transferOwnershipCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = transferOwnershipReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transferOwnership(address)"; + const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::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 { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + ///Container for all the [`DummySeBep20`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum DummySeBep20Calls { + #[allow(missing_docs)] + allowance(allowanceCall), + #[allow(missing_docs)] + approve(approveCall), + #[allow(missing_docs)] + balanceOf(balanceOfCall), + #[allow(missing_docs)] + balanceOfUnderlying(balanceOfUnderlyingCall), + #[allow(missing_docs)] + decimals(decimalsCall), + #[allow(missing_docs)] + decreaseAllowance(decreaseAllowanceCall), + #[allow(missing_docs)] + increaseAllowance(increaseAllowanceCall), + #[allow(missing_docs)] + mint(mintCall), + #[allow(missing_docs)] + mintBehalf(mintBehalfCall), + #[allow(missing_docs)] + name(nameCall), + #[allow(missing_docs)] + owner(ownerCall), + #[allow(missing_docs)] + redeem(redeemCall), + #[allow(missing_docs)] + renounceOwnership(renounceOwnershipCall), + #[allow(missing_docs)] + sudoMint(sudoMintCall), + #[allow(missing_docs)] + symbol(symbolCall), + #[allow(missing_docs)] + totalSupply(totalSupplyCall), + #[allow(missing_docs)] + transfer(transferCall), + #[allow(missing_docs)] + transferFrom(transferFromCall), + #[allow(missing_docs)] + transferOwnership(transferOwnershipCall), + } + #[automatically_derived] + impl DummySeBep20Calls { + /// 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, 50u8, 62u8, 3u8], + [35u8, 184u8, 114u8, 221u8], + [45u8, 104u8, 140u8, 168u8], + [49u8, 60u8, 229u8, 103u8], + [57u8, 80u8, 147u8, 81u8], + [58u8, 249u8, 230u8, 105u8], + [112u8, 160u8, 130u8, 49u8], + [113u8, 80u8, 24u8, 166u8], + [141u8, 165u8, 203u8, 91u8], + [149u8, 216u8, 155u8, 65u8], + [160u8, 113u8, 45u8, 104u8], + [164u8, 87u8, 194u8, 215u8], + [169u8, 5u8, 156u8, 187u8], + [219u8, 0u8, 106u8, 117u8], + [221u8, 98u8, 237u8, 62u8], + [242u8, 253u8, 227u8, 139u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for DummySeBep20Calls { + const NAME: &'static str = "DummySeBep20Calls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 19usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::allowance(_) => { + ::SELECTOR + } + Self::approve(_) => ::SELECTOR, + Self::balanceOf(_) => { + ::SELECTOR + } + Self::balanceOfUnderlying(_) => { + ::SELECTOR + } + Self::decimals(_) => ::SELECTOR, + Self::decreaseAllowance(_) => { + ::SELECTOR + } + Self::increaseAllowance(_) => { + ::SELECTOR + } + Self::mint(_) => ::SELECTOR, + Self::mintBehalf(_) => { + ::SELECTOR + } + Self::name(_) => ::SELECTOR, + Self::owner(_) => ::SELECTOR, + Self::redeem(_) => ::SELECTOR, + Self::renounceOwnership(_) => { + ::SELECTOR + } + Self::sudoMint(_) => ::SELECTOR, + Self::symbol(_) => ::SELECTOR, + Self::totalSupply(_) => { + ::SELECTOR + } + Self::transfer(_) => ::SELECTOR, + Self::transferFrom(_) => { + ::SELECTOR + } + Self::transferOwnership(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn name(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummySeBep20Calls::name) + } + name + }, + { + fn approve( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummySeBep20Calls::approve) + } + approve + }, + { + fn totalSupply( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummySeBep20Calls::totalSupply) + } + totalSupply + }, + { + fn mintBehalf( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummySeBep20Calls::mintBehalf) + } + mintBehalf + }, + { + fn transferFrom( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummySeBep20Calls::transferFrom) + } + transferFrom + }, + { + fn sudoMint( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummySeBep20Calls::sudoMint) + } + sudoMint + }, + { + fn decimals( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummySeBep20Calls::decimals) + } + decimals + }, + { + fn increaseAllowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummySeBep20Calls::increaseAllowance) + } + increaseAllowance + }, + { + fn balanceOfUnderlying( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummySeBep20Calls::balanceOfUnderlying) + } + balanceOfUnderlying + }, + { + fn balanceOf( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummySeBep20Calls::balanceOf) + } + balanceOf + }, + { + fn renounceOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummySeBep20Calls::renounceOwnership) + } + renounceOwnership + }, + { + fn owner(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummySeBep20Calls::owner) + } + owner + }, + { + fn symbol( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummySeBep20Calls::symbol) + } + symbol + }, + { + fn mint(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummySeBep20Calls::mint) + } + mint + }, + { + fn decreaseAllowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummySeBep20Calls::decreaseAllowance) + } + decreaseAllowance + }, + { + fn transfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummySeBep20Calls::transfer) + } + transfer + }, + { + fn redeem( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummySeBep20Calls::redeem) + } + redeem + }, + { + fn allowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummySeBep20Calls::allowance) + } + allowance + }, + { + fn transferOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummySeBep20Calls::transferOwnership) + } + transferOwnership + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn name(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummySeBep20Calls::name) + } + name + }, + { + fn approve( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummySeBep20Calls::approve) + } + approve + }, + { + fn totalSupply( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummySeBep20Calls::totalSupply) + } + totalSupply + }, + { + fn mintBehalf( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummySeBep20Calls::mintBehalf) + } + mintBehalf + }, + { + fn transferFrom( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummySeBep20Calls::transferFrom) + } + transferFrom + }, + { + fn sudoMint( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummySeBep20Calls::sudoMint) + } + sudoMint + }, + { + fn decimals( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummySeBep20Calls::decimals) + } + decimals + }, + { + fn increaseAllowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummySeBep20Calls::increaseAllowance) + } + increaseAllowance + }, + { + fn balanceOfUnderlying( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummySeBep20Calls::balanceOfUnderlying) + } + balanceOfUnderlying + }, + { + fn balanceOf( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummySeBep20Calls::balanceOf) + } + balanceOf + }, + { + fn renounceOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummySeBep20Calls::renounceOwnership) + } + renounceOwnership + }, + { + fn owner(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummySeBep20Calls::owner) + } + owner + }, + { + fn symbol( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummySeBep20Calls::symbol) + } + symbol + }, + { + fn mint(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummySeBep20Calls::mint) + } + mint + }, + { + fn decreaseAllowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummySeBep20Calls::decreaseAllowance) + } + decreaseAllowance + }, + { + fn transfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummySeBep20Calls::transfer) + } + transfer + }, + { + fn redeem( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummySeBep20Calls::redeem) + } + redeem + }, + { + fn allowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummySeBep20Calls::allowance) + } + allowance + }, + { + fn transferOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummySeBep20Calls::transferOwnership) + } + transferOwnership + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::allowance(inner) => { + ::abi_encoded_size(inner) + } + Self::approve(inner) => { + ::abi_encoded_size(inner) + } + Self::balanceOf(inner) => { + ::abi_encoded_size(inner) + } + Self::balanceOfUnderlying(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::decimals(inner) => { + ::abi_encoded_size(inner) + } + Self::decreaseAllowance(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::increaseAllowance(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::mint(inner) => { + ::abi_encoded_size(inner) + } + Self::mintBehalf(inner) => { + ::abi_encoded_size(inner) + } + Self::name(inner) => { + ::abi_encoded_size(inner) + } + Self::owner(inner) => { + ::abi_encoded_size(inner) + } + Self::redeem(inner) => { + ::abi_encoded_size(inner) + } + Self::renounceOwnership(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::sudoMint(inner) => { + ::abi_encoded_size(inner) + } + Self::symbol(inner) => { + ::abi_encoded_size(inner) + } + Self::totalSupply(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::transfer(inner) => { + ::abi_encoded_size(inner) + } + Self::transferFrom(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::transferOwnership(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::allowance(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::approve(inner) => { + ::abi_encode_raw(inner, out) + } + Self::balanceOf(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::balanceOfUnderlying(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::decimals(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::decreaseAllowance(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::increaseAllowance(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::mint(inner) => { + ::abi_encode_raw(inner, out) + } + Self::mintBehalf(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::name(inner) => { + ::abi_encode_raw(inner, out) + } + Self::owner(inner) => { + ::abi_encode_raw(inner, out) + } + Self::redeem(inner) => { + ::abi_encode_raw(inner, out) + } + Self::renounceOwnership(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::sudoMint(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::symbol(inner) => { + ::abi_encode_raw(inner, out) + } + Self::totalSupply(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transfer(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transferFrom(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transferOwnership(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`DummySeBep20`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum DummySeBep20Events { + #[allow(missing_docs)] + Approval(Approval), + #[allow(missing_docs)] + OwnershipTransferred(OwnershipTransferred), + #[allow(missing_docs)] + Transfer(Transfer), + } + #[automatically_derived] + impl DummySeBep20Events { + /// 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]] = &[ + [ + 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, 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, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for DummySeBep20Events { + const NAME: &'static str = "DummySeBep20Events"; + const COUNT: usize = 3usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Approval) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::OwnershipTransferred) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Transfer) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 DummySeBep20Events { + 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::OwnershipTransferred(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::OwnershipTransferred(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 as alloy_contract; + /**Creates a new wrapper around an on-chain [`DummySeBep20`](self) contract instance. + +See the [wrapper's documentation](`DummySeBep20Instance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> DummySeBep20Instance { + DummySeBep20Instance::::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: alloy_contract::private::Network, + >( + provider: P, + name_: alloy::sol_types::private::String, + symbol_: alloy::sol_types::private::String, + _doMint: bool, + _suppressMintError: bool, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + DummySeBep20Instance::< + P, + N, + >::deploy(provider, name_, symbol_, _doMint, _suppressMintError) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + name_: alloy::sol_types::private::String, + symbol_: alloy::sol_types::private::String, + _doMint: bool, + _suppressMintError: bool, + ) -> alloy_contract::RawCallBuilder { + DummySeBep20Instance::< + P, + N, + >::deploy_builder(provider, name_, symbol_, _doMint, _suppressMintError) + } + /**A [`DummySeBep20`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`DummySeBep20`](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 DummySeBep20Instance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for DummySeBep20Instance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("DummySeBep20Instance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummySeBep20Instance { + /**Creates a new wrapper around an on-chain [`DummySeBep20`](self) contract instance. + +See the [wrapper's documentation](`DummySeBep20Instance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + name_: alloy::sol_types::private::String, + symbol_: alloy::sol_types::private::String, + _doMint: bool, + _suppressMintError: bool, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder( + provider, + name_, + symbol_, + _doMint, + _suppressMintError, + ); + 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, + name_: alloy::sol_types::private::String, + symbol_: alloy::sol_types::private::String, + _doMint: bool, + _suppressMintError: bool, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + name_, + symbol_, + _doMint, + _suppressMintError, + }, + )[..], + ] + .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 DummySeBep20Instance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> DummySeBep20Instance { + DummySeBep20Instance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummySeBep20Instance { + /// 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( + &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 [`balanceOfUnderlying`] function. + pub fn balanceOfUnderlying( + &self, + _0: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, balanceOfUnderlyingCall, N> { + self.call_builder(&balanceOfUnderlyingCall(_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 [`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 [`mint`] function. + pub fn mint( + &self, + _0: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> { + self.call_builder(&mintCall(_0)) + } + ///Creates a new call builder for the [`mintBehalf`] function. + pub fn mintBehalf( + &self, + receiver: alloy::sol_types::private::Address, + mintAmount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, mintBehalfCall, N> { + self.call_builder( + &mintBehalfCall { + receiver, + mintAmount, + }, + ) + } + ///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 [`redeem`] function. + pub fn redeem( + &self, + _0: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, redeemCall, N> { + self.call_builder(&redeemCall(_0)) + } + ///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 [`sudoMint`] function. + pub fn sudoMint( + &self, + to: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, sudoMintCall, N> { + self.call_builder(&sudoMintCall { to, amount }) + } + ///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, + 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, + }, + ) + } + ///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. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummySeBep20Instance { + /// 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( + &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::() + } + ///Creates a new event filter for the [`OwnershipTransferred`] event. + pub fn OwnershipTransferred_filter( + &self, + ) -> alloy_contract::Event<&P, OwnershipTransferred, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`Transfer`] event. + pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/dummy_shoe_bill_token.rs b/crates/bindings/src/dummy_shoe_bill_token.rs new file mode 100644 index 000000000..e6811d659 --- /dev/null +++ b/crates/bindings/src/dummy_shoe_bill_token.rs @@ -0,0 +1,4696 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface DummyShoeBillToken { + event Approval(address indexed owner, address indexed spender, uint256 value); + event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); + event Transfer(address indexed from, address indexed to, uint256 value); + + constructor(string name_, string symbol_, bool _doMint); + + 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 balanceOfUnderlying(address) external pure 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 mint(uint256 mintAmount) external returns (uint256); + function name() external view returns (string memory); + function owner() external view returns (address); + function renounceOwnership() external; + function sudoMint(address to, uint256 amount) external; + function symbol() external view returns (string memory); + function totalSupply() external view returns (uint256); + function transfer(address to, uint256 amount) external returns (bool); + function transferFrom(address from, address to, uint256 amount) external returns (bool); + function transferOwnership(address newOwner) external; +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "name_", + "type": "string", + "internalType": "string" + }, + { + "name": "symbol_", + "type": "string", + "internalType": "string" + }, + { + "name": "_doMint", + "type": "bool", + "internalType": "bool" + } + ], + "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": "balanceOfUnderlying", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "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": "mint", + "inputs": [ + { + "name": "mintAmount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "name", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "owner", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "renounceOwnership", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "sudoMint", + "inputs": [ + { + "name": "to", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "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": "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" + }, + { + "type": "function", + "name": "transferOwnership", + "inputs": [ + { + "name": "newOwner", + "type": "address", + "internalType": "address" + } + ], + "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": "OwnershipTransferred", + "inputs": [ + { + "name": "previousOwner", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "newOwner", + "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 DummyShoeBillToken { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x608060405234801561000f575f5ffd5b506040516110f73803806110f783398101604081905261002e91610178565b8282600361003c8382610278565b5060046100498282610278565b50505061006261005d61008660201b60201c565b61008a565b60058054911515600160a01b0260ff60a01b19909216919091179055506103329050565b3390565b600580546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0905f90a35050565b634e487b7160e01b5f52604160045260245ffd5b5f82601f8301126100fe575f5ffd5b81516001600160401b03811115610117576101176100db565b604051601f8201601f19908116603f011681016001600160401b0381118282101715610145576101456100db565b60405281815283820160200185101561015c575f5ffd5b8160208501602083015e5f918101602001919091529392505050565b5f5f5f6060848603121561018a575f5ffd5b83516001600160401b0381111561019f575f5ffd5b6101ab868287016100ef565b602086015190945090506001600160401b038111156101c8575f5ffd5b6101d4868287016100ef565b925050604084015180151581146101e9575f5ffd5b809150509250925092565b600181811c9082168061020857607f821691505b60208210810361022657634e487b7160e01b5f52602260045260245ffd5b50919050565b601f82111561027357805f5260205f20601f840160051c810160208510156102515750805b601f840160051c820191505b81811015610270575f815560010161025d565b50505b505050565b81516001600160401b03811115610291576102916100db565b6102a58161029f84546101f4565b8461022c565b6020601f8211600181146102d7575f83156102c05750848201515b5f19600385901b1c1916600184901b178455610270565b5f84815260208120601f198516915b8281101561030657878501518255602094850194600190920191016102e6565b508482101561032357868401515f19600387901b60f8161c191681555b50505050600190811b01905550565b610db88061033f5f395ff3fe608060405234801561000f575f5ffd5b5060043610610115575f3560e01c806370a08231116100ad578063a0712d681161007d578063a9059cbb11610063578063a9059cbb14610242578063dd62ed3e14610255578063f2fde38b1461028d575f5ffd5b8063a0712d681461021c578063a457c2d71461022f575f5ffd5b806370a08231146101c9578063715018a6146101f15780638da5cb5b146101f957806395d89b4114610214575f5ffd5b80632d688ca8116100e85780632d688ca81461017f578063313ce5671461019457806339509351146101a35780633af9e669146101b6575f5ffd5b806306fdde0314610119578063095ea7b31461013757806318160ddd1461015a57806323b872dd1461016c575b5f5ffd5b6101216102a0565b60405161012e9190610bc1565b60405180910390f35b61014a610145366004610c2f565b610330565b604051901515815260200161012e565b6002545b60405190815260200161012e565b61014a61017a366004610c57565b610349565b61019261018d366004610c2f565b61036c565b005b6040516012815260200161012e565b61014a6101b1366004610c2f565b6103d9565b61015e6101c4366004610c91565b505f90565b61015e6101d7366004610c91565b6001600160a01b03165f9081526020819052604090205490565b610192610417565b6005546040516001600160a01b03909116815260200161012e565b61012161047c565b61015e61022a366004610cb1565b61048b565b61014a61023d366004610c2f565b6104c9565b61014a610250366004610c2f565b610572565b61015e610263366004610cc8565b6001600160a01b039182165f90815260016020908152604080832093909416825291909152205490565b61019261029b366004610c91565b61057f565b6060600380546102af90610cf9565b80601f01602080910402602001604051908101604052809291908181526020018280546102db90610cf9565b80156103265780601f106102fd57610100808354040283529160200191610326565b820191905f5260205f20905b81548152906001019060200180831161030957829003601f168201915b5050505050905090565b5f3361033d818585610661565b60019150505b92915050565b5f336103568582856107b8565b610361858585610867565b506001949350505050565b6005546001600160a01b031633146103cb5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064015b60405180910390fd5b6103d58282610a7c565b5050565b335f8181526001602090815260408083206001600160a01b038716845290915281205490919061033d9082908690610412908790610d4a565b610661565b6005546001600160a01b031633146104715760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016103c2565b61047a5f610b58565b565b6060600480546102af90610cf9565b6005545f9074010000000000000000000000000000000000000000900460ff16156104c1576104ba3383610a7c565b505f919050565b506001919050565b335f8181526001602090815260408083206001600160a01b0387168452909152812054909190838110156105655760405162461bcd60e51b815260206004820152602560248201527f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f7760448201527f207a65726f00000000000000000000000000000000000000000000000000000060648201526084016103c2565b6103618286868403610661565b5f3361033d818585610867565b6005546001600160a01b031633146105d95760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016103c2565b6001600160a01b0381166106555760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f646472657373000000000000000000000000000000000000000000000000000060648201526084016103c2565b61065e81610b58565b50565b6001600160a01b0383166106dc5760405162461bcd60e51b8152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f2061646460448201527f726573730000000000000000000000000000000000000000000000000000000060648201526084016103c2565b6001600160a01b0382166107585760405162461bcd60e51b815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f20616464726560448201527f737300000000000000000000000000000000000000000000000000000000000060648201526084016103c2565b6001600160a01b038381165f8181526001602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a3505050565b6001600160a01b038381165f908152600160209081526040808320938616835292905220547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff811461086157818110156108545760405162461bcd60e51b815260206004820152601d60248201527f45524332303a20696e73756666696369656e7420616c6c6f77616e636500000060448201526064016103c2565b6108618484848403610661565b50505050565b6001600160a01b0383166108e35760405162461bcd60e51b815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f20616460448201527f647265737300000000000000000000000000000000000000000000000000000060648201526084016103c2565b6001600160a01b03821661095f5760405162461bcd60e51b815260206004820152602360248201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260448201527f657373000000000000000000000000000000000000000000000000000000000060648201526084016103c2565b6001600160a01b0383165f90815260208190526040902054818110156109ed5760405162461bcd60e51b815260206004820152602660248201527f45524332303a207472616e7366657220616d6f756e742065786365656473206260448201527f616c616e6365000000000000000000000000000000000000000000000000000060648201526084016103c2565b6001600160a01b038085165f90815260208190526040808220858503905591851681529081208054849290610a23908490610d4a565b92505081905550826001600160a01b0316846001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef84604051610a6f91815260200190565b60405180910390a3610861565b6001600160a01b038216610ad25760405162461bcd60e51b815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f20616464726573730060448201526064016103c2565b8060025f828254610ae39190610d4a565b90915550506001600160a01b0382165f9081526020819052604081208054839290610b0f908490610d4a565b90915550506040518181526001600160a01b038316905f907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9060200160405180910390a35050565b600580546001600160a01b038381167fffffffffffffffffffffffff0000000000000000000000000000000000000000831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0905f90a35050565b602081525f82518060208401528060208501604085015e5f6040828501015260407fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f83011684010191505092915050565b80356001600160a01b0381168114610c2a575f5ffd5b919050565b5f5f60408385031215610c40575f5ffd5b610c4983610c14565b946020939093013593505050565b5f5f5f60608486031215610c69575f5ffd5b610c7284610c14565b9250610c8060208501610c14565b929592945050506040919091013590565b5f60208284031215610ca1575f5ffd5b610caa82610c14565b9392505050565b5f60208284031215610cc1575f5ffd5b5035919050565b5f5f60408385031215610cd9575f5ffd5b610ce283610c14565b9150610cf060208401610c14565b90509250929050565b600181811c90821680610d0d57607f821691505b602082108103610d44577f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b50919050565b80820180821115610343577f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffdfea2646970667358221220174364a854113c1b7831a6ab98f32542d3a3b5504c4231f7e1a08b555e5f9f6d64736f6c634300081c0033 + /// ``` + #[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__\xFD[P`@Qa\x10\xF78\x03\x80a\x10\xF7\x839\x81\x01`@\x81\x90Ra\0.\x91a\x01xV[\x82\x82`\x03a\0<\x83\x82a\x02xV[P`\x04a\0I\x82\x82a\x02xV[PPPa\0ba\0]a\0\x86` \x1B` \x1CV[a\0\x8AV[`\x05\x80T\x91\x15\x15`\x01`\xA0\x1B\x02`\xFF`\xA0\x1B\x19\x90\x92\x16\x91\x90\x91\x17\x90UPa\x032\x90PV[3\x90V[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x01`\x01`\xA0\x1B\x03\x19\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x82`\x1F\x83\x01\x12a\0\xFEW__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\x17Wa\x01\x17a\0\xDBV[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x01EWa\x01Ea\0\xDBV[`@R\x81\x81R\x83\x82\x01` \x01\x85\x10\x15a\x01\\W__\xFD[\x81` \x85\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[___``\x84\x86\x03\x12\x15a\x01\x8AW__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\x9FW__\xFD[a\x01\xAB\x86\x82\x87\x01a\0\xEFV[` \x86\x01Q\x90\x94P\x90P`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\xC8W__\xFD[a\x01\xD4\x86\x82\x87\x01a\0\xEFV[\x92PP`@\x84\x01Q\x80\x15\x15\x81\x14a\x01\xE9W__\xFD[\x80\x91PP\x92P\x92P\x92V[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x02\x08W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x02&WcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\x02sW\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x02QWP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x02pW_\x81U`\x01\x01a\x02]V[PP[PPPV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x02\x91Wa\x02\x91a\0\xDBV[a\x02\xA5\x81a\x02\x9F\x84Ta\x01\xF4V[\x84a\x02,V[` `\x1F\x82\x11`\x01\x81\x14a\x02\xD7W_\x83\x15a\x02\xC0WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x02pV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x03\x06W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x02\xE6V[P\x84\x82\x10\x15a\x03#W\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[a\r\xB8\x80a\x03?_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cp\xA0\x821\x11a\0\xADW\x80c\xA0q-h\x11a\0}W\x80c\xA9\x05\x9C\xBB\x11a\0cW\x80c\xA9\x05\x9C\xBB\x14a\x02BW\x80c\xDDb\xED>\x14a\x02UW\x80c\xF2\xFD\xE3\x8B\x14a\x02\x8DW__\xFD[\x80c\xA0q-h\x14a\x02\x1CW\x80c\xA4W\xC2\xD7\x14a\x02/W__\xFD[\x80cp\xA0\x821\x14a\x01\xC9W\x80cqP\x18\xA6\x14a\x01\xF1W\x80c\x8D\xA5\xCB[\x14a\x01\xF9W\x80c\x95\xD8\x9BA\x14a\x02\x14W__\xFD[\x80c-h\x8C\xA8\x11a\0\xE8W\x80c-h\x8C\xA8\x14a\x01\x7FW\x80c1<\xE5g\x14a\x01\x94W\x80c9P\x93Q\x14a\x01\xA3W\x80c:\xF9\xE6i\x14a\x01\xB6W__\xFD[\x80c\x06\xFD\xDE\x03\x14a\x01\x19W\x80c\t^\xA7\xB3\x14a\x017W\x80c\x18\x16\r\xDD\x14a\x01ZW\x80c#\xB8r\xDD\x14a\x01lW[__\xFD[a\x01!a\x02\xA0V[`@Qa\x01.\x91\x90a\x0B\xC1V[`@Q\x80\x91\x03\x90\xF3[a\x01Ja\x01E6`\x04a\x0C/V[a\x030V[`@Q\x90\x15\x15\x81R` \x01a\x01.V[`\x02T[`@Q\x90\x81R` \x01a\x01.V[a\x01Ja\x01z6`\x04a\x0CWV[a\x03IV[a\x01\x92a\x01\x8D6`\x04a\x0C/V[a\x03lV[\0[`@Q`\x12\x81R` \x01a\x01.V[a\x01Ja\x01\xB16`\x04a\x0C/V[a\x03\xD9V[a\x01^a\x01\xC46`\x04a\x0C\x91V[P_\x90V[a\x01^a\x01\xD76`\x04a\x0C\x91V[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R` \x81\x90R`@\x90 T\x90V[a\x01\x92a\x04\x17V[`\x05T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01.V[a\x01!a\x04|V[a\x01^a\x02*6`\x04a\x0C\xB1V[a\x04\x8BV[a\x01Ja\x02=6`\x04a\x0C/V[a\x04\xC9V[a\x01Ja\x02P6`\x04a\x0C/V[a\x05rV[a\x01^a\x02c6`\x04a\x0C\xC8V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[a\x01\x92a\x02\x9B6`\x04a\x0C\x91V[a\x05\x7FV[```\x03\x80Ta\x02\xAF\x90a\x0C\xF9V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\xDB\x90a\x0C\xF9V[\x80\x15a\x03&W\x80`\x1F\x10a\x02\xFDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03&V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\tW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[_3a\x03=\x81\x85\x85a\x06aV[`\x01\x91PP[\x92\x91PPV[_3a\x03V\x85\x82\x85a\x07\xB8V[a\x03a\x85\x85\x85a\x08gV[P`\x01\x94\x93PPPPV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x03\xCBW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\xD5\x82\x82a\n|V[PPV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90a\x03=\x90\x82\x90\x86\x90a\x04\x12\x90\x87\x90a\rJV[a\x06aV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x04qW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03\xC2V[a\x04z_a\x0BXV[V[```\x04\x80Ta\x02\xAF\x90a\x0C\xF9V[`\x05T_\x90t\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x04\xC1Wa\x04\xBA3\x83a\n|V[P_\x91\x90PV[P`\x01\x91\x90PV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90\x83\x81\x10\x15a\x05eW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[a\x03a\x82\x86\x86\x84\x03a\x06aV[_3a\x03=\x81\x85\x85a\x08gV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x05\xD9W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x06UW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01R\x7Fddress\0\0\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\x03\xC2V[a\x06^\x81a\x0BXV[PV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x06\xDCW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x07XW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\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[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R 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\x81\x14a\x08aW\x81\x81\x10\x15a\x08TW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FERC20: insufficient allowance\0\0\0`D\x82\x01R`d\x01a\x03\xC2V[a\x08a\x84\x84\x84\x84\x03a\x06aV[PPPPV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x08\xE3W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\t_W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R` \x81\x90R`@\x90 T\x81\x81\x10\x15a\t\xEDW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16_\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R\x90\x81 \x80T\x84\x92\x90a\n#\x90\x84\x90a\rJV[\x92PP\x81\x90UP\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\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\no\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3a\x08aV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\n\xD2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FERC20: mint to the zero address\0`D\x82\x01R`d\x01a\x03\xC2V[\x80`\x02_\x82\x82Ta\n\xE3\x91\x90a\rJV[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x83\x92\x90a\x0B\x0F\x90\x84\x90a\rJV[\x90\x91UPP`@Q\x81\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90_\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[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\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\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\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\x84\x01\x01\x91PP\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0C*W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0C@W__\xFD[a\x0CI\x83a\x0C\x14V[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x0CiW__\xFD[a\x0Cr\x84a\x0C\x14V[\x92Pa\x0C\x80` \x85\x01a\x0C\x14V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\x0C\xA1W__\xFD[a\x0C\xAA\x82a\x0C\x14V[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x0C\xC1W__\xFD[P5\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0C\xD9W__\xFD[a\x0C\xE2\x83a\x0C\x14V[\x91Pa\x0C\xF0` \x84\x01a\x0C\x14V[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\r\rW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\rDW\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[P\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x03CW\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\xFE\xA2dipfsX\"\x12 \x17Cd\xA8T\x11<\x1Bx1\xA6\xAB\x98\xF3%B\xD3\xA3\xB5PLB1\xF7\xE1\xA0\x8BU^_\x9FmdsolcC\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\x01\x15W_5`\xE0\x1C\x80cp\xA0\x821\x11a\0\xADW\x80c\xA0q-h\x11a\0}W\x80c\xA9\x05\x9C\xBB\x11a\0cW\x80c\xA9\x05\x9C\xBB\x14a\x02BW\x80c\xDDb\xED>\x14a\x02UW\x80c\xF2\xFD\xE3\x8B\x14a\x02\x8DW__\xFD[\x80c\xA0q-h\x14a\x02\x1CW\x80c\xA4W\xC2\xD7\x14a\x02/W__\xFD[\x80cp\xA0\x821\x14a\x01\xC9W\x80cqP\x18\xA6\x14a\x01\xF1W\x80c\x8D\xA5\xCB[\x14a\x01\xF9W\x80c\x95\xD8\x9BA\x14a\x02\x14W__\xFD[\x80c-h\x8C\xA8\x11a\0\xE8W\x80c-h\x8C\xA8\x14a\x01\x7FW\x80c1<\xE5g\x14a\x01\x94W\x80c9P\x93Q\x14a\x01\xA3W\x80c:\xF9\xE6i\x14a\x01\xB6W__\xFD[\x80c\x06\xFD\xDE\x03\x14a\x01\x19W\x80c\t^\xA7\xB3\x14a\x017W\x80c\x18\x16\r\xDD\x14a\x01ZW\x80c#\xB8r\xDD\x14a\x01lW[__\xFD[a\x01!a\x02\xA0V[`@Qa\x01.\x91\x90a\x0B\xC1V[`@Q\x80\x91\x03\x90\xF3[a\x01Ja\x01E6`\x04a\x0C/V[a\x030V[`@Q\x90\x15\x15\x81R` \x01a\x01.V[`\x02T[`@Q\x90\x81R` \x01a\x01.V[a\x01Ja\x01z6`\x04a\x0CWV[a\x03IV[a\x01\x92a\x01\x8D6`\x04a\x0C/V[a\x03lV[\0[`@Q`\x12\x81R` \x01a\x01.V[a\x01Ja\x01\xB16`\x04a\x0C/V[a\x03\xD9V[a\x01^a\x01\xC46`\x04a\x0C\x91V[P_\x90V[a\x01^a\x01\xD76`\x04a\x0C\x91V[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R` \x81\x90R`@\x90 T\x90V[a\x01\x92a\x04\x17V[`\x05T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01.V[a\x01!a\x04|V[a\x01^a\x02*6`\x04a\x0C\xB1V[a\x04\x8BV[a\x01Ja\x02=6`\x04a\x0C/V[a\x04\xC9V[a\x01Ja\x02P6`\x04a\x0C/V[a\x05rV[a\x01^a\x02c6`\x04a\x0C\xC8V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[a\x01\x92a\x02\x9B6`\x04a\x0C\x91V[a\x05\x7FV[```\x03\x80Ta\x02\xAF\x90a\x0C\xF9V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\xDB\x90a\x0C\xF9V[\x80\x15a\x03&W\x80`\x1F\x10a\x02\xFDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03&V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\tW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[_3a\x03=\x81\x85\x85a\x06aV[`\x01\x91PP[\x92\x91PPV[_3a\x03V\x85\x82\x85a\x07\xB8V[a\x03a\x85\x85\x85a\x08gV[P`\x01\x94\x93PPPPV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x03\xCBW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\xD5\x82\x82a\n|V[PPV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90a\x03=\x90\x82\x90\x86\x90a\x04\x12\x90\x87\x90a\rJV[a\x06aV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x04qW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03\xC2V[a\x04z_a\x0BXV[V[```\x04\x80Ta\x02\xAF\x90a\x0C\xF9V[`\x05T_\x90t\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x04\xC1Wa\x04\xBA3\x83a\n|V[P_\x91\x90PV[P`\x01\x91\x90PV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90\x83\x81\x10\x15a\x05eW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[a\x03a\x82\x86\x86\x84\x03a\x06aV[_3a\x03=\x81\x85\x85a\x08gV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x05\xD9W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x06UW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01R\x7Fddress\0\0\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\x03\xC2V[a\x06^\x81a\x0BXV[PV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x06\xDCW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x07XW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\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[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R 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\x81\x14a\x08aW\x81\x81\x10\x15a\x08TW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FERC20: insufficient allowance\0\0\0`D\x82\x01R`d\x01a\x03\xC2V[a\x08a\x84\x84\x84\x84\x03a\x06aV[PPPPV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x08\xE3W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\t_W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R` \x81\x90R`@\x90 T\x81\x81\x10\x15a\t\xEDW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16_\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R\x90\x81 \x80T\x84\x92\x90a\n#\x90\x84\x90a\rJV[\x92PP\x81\x90UP\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\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\no\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3a\x08aV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\n\xD2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FERC20: mint to the zero address\0`D\x82\x01R`d\x01a\x03\xC2V[\x80`\x02_\x82\x82Ta\n\xE3\x91\x90a\rJV[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x83\x92\x90a\x0B\x0F\x90\x84\x90a\rJV[\x90\x91UPP`@Q\x81\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90_\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[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\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\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\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\x84\x01\x01\x91PP\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0C*W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0C@W__\xFD[a\x0CI\x83a\x0C\x14V[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x0CiW__\xFD[a\x0Cr\x84a\x0C\x14V[\x92Pa\x0C\x80` \x85\x01a\x0C\x14V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\x0C\xA1W__\xFD[a\x0C\xAA\x82a\x0C\x14V[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x0C\xC1W__\xFD[P5\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0C\xD9W__\xFD[a\x0C\xE2\x83a\x0C\x14V[\x91Pa\x0C\xF0` \x84\x01a\x0C\x14V[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\r\rW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\rDW\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[P\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x03CW\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\xFE\xA2dipfsX\"\x12 \x17Cd\xA8T\x11<\x1Bx1\xA6\xAB\x98\xF3%B\xD3\xA3\xB5PLB1\xF7\xE1\xA0\x8BU^_\x9FmdsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Approval { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + 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, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + owner: topics.1, + spender: topics.2, + value: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.value), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.owner, + ); + out[2usize] = ::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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for OwnershipTransferred { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + 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, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + previousOwner: topics.1, + newOwner: topics.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return 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) -> ::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() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.previousOwner, + ); + out[2usize] = ::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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Transfer { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + 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, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + from: topics.1, + to: topics.2, + value: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.value), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.from, + ); + out[2usize] = ::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_, bool _doMint); +```*/ + #[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, + #[allow(missing_docs)] + pub _doMint: bool, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Bool, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::String, + alloy::sol_types::private::String, + bool, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value.name_, value.symbol_, value._doMint) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + name_: tuple.0, + symbol_: tuple.1, + _doMint: tuple.2, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolConstructor for constructorCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Bool, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.name_, + ), + ::tokenize( + &self.symbol_, + ), + ::tokenize( + &self._doMint, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: allowanceCall) -> Self { + (value.owner, value.spender) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for allowanceCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + owner: tuple.0, + spender: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: allowanceReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "allowance(address,address)"; + const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.owner, + ), + ::tokenize( + &self.spender, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: allowanceReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: approveCall) -> Self { + (value.spender, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for approveCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + spender: tuple.0, + amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: approveReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "approve(address,uint256)"; + const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.spender, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: approveReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: balanceOfCall) -> Self { + (value.account,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for balanceOfCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { account: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: balanceOfReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "balanceOf(address)"; + const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.account, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: balanceOfReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `balanceOfUnderlying(address)` and selector `0x3af9e669`. +```solidity +function balanceOfUnderlying(address) external pure returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct balanceOfUnderlyingCall(pub alloy::sol_types::private::Address); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`balanceOfUnderlying(address)`](balanceOfUnderlyingCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct balanceOfUnderlyingReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: balanceOfUnderlyingCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for balanceOfUnderlyingCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: balanceOfUnderlyingReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for balanceOfUnderlyingReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for balanceOfUnderlyingCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "balanceOfUnderlying(address)"; + const SELECTOR: [u8; 4] = [58u8, 249u8, 230u8, 105u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.0, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: balanceOfUnderlyingReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: balanceOfUnderlyingReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: decimalsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for decimalsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: decimalsReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for decimalsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for decimalsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = u8; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "decimals()"; + const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: decimalsReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: decreaseAllowanceCall) -> Self { + (value.spender, value.subtractedValue) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for decreaseAllowanceCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + spender: tuple.0, + subtractedValue: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: decreaseAllowanceReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)"; + const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.spender, + ), + as alloy_sol_types::SolType>::tokenize(&self.subtractedValue), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: decreaseAllowanceReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: increaseAllowanceCall) -> Self { + (value.spender, value.addedValue) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for increaseAllowanceCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + spender: tuple.0, + addedValue: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: increaseAllowanceReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "increaseAllowance(address,uint256)"; + const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.spender, + ), + as alloy_sol_types::SolType>::tokenize(&self.addedValue), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: increaseAllowanceReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `mint(uint256)` and selector `0xa0712d68`. +```solidity +function mint(uint256 mintAmount) external returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct mintCall { + #[allow(missing_docs)] + pub mintAmount: alloy::sol_types::private::primitives::aliases::U256, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`mint(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: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: mintCall) -> Self { + (value.mintAmount,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for mintCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { mintAmount: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: mintReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "mint(uint256)"; + const SELECTOR: [u8; 4] = [160u8, 113u8, 45u8, 104u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.mintAmount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: mintReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: nameCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for nameCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: nameReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for nameReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for nameCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::String; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "name()"; + const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: nameReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ownerCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ownerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ownerReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ownerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for ownerCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "owner()"; + const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: ownerReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: renounceOwnershipCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for renounceOwnershipCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: renounceOwnershipReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for renounceOwnershipReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl renounceOwnershipReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for renounceOwnershipCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = renounceOwnershipReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "renounceOwnership()"; + const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8]; + #[inline] + fn new<'a>( + tuple: 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 { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `sudoMint(address,uint256)` and selector `0x2d688ca8`. +```solidity +function sudoMint(address to, uint256 amount) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct sudoMintCall { + #[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 [`sudoMint(address,uint256)`](sudoMintCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct sudoMintReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: sudoMintCall) -> Self { + (value.to, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for sudoMintCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + to: tuple.0, + amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: sudoMintReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for sudoMintReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl sudoMintReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for sudoMintCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = sudoMintReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "sudoMint(address,uint256)"; + const SELECTOR: [u8; 4] = [45u8, 104u8, 140u8, 168u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.to, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + sudoMintReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: symbolCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for symbolCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: symbolReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for symbolReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for symbolCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::String; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "symbol()"; + const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: symbolReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: totalSupplyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for totalSupplyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: totalSupplyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for totalSupplyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for totalSupplyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "totalSupply()"; + const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: totalSupplyReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferCall) -> Self { + (value.to, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for transferCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + to: tuple.0, + amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transfer(address,uint256)"; + const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.to, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: transferReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferFromCall) -> Self { + (value.from, value.to, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for transferFromCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + from: tuple.0, + to: tuple.1, + amount: tuple.2, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferFromReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transferFrom(address,address,uint256)"; + const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.from, + ), + ::tokenize( + &self.to, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: transferFromReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: transferOwnershipCall) -> Self { + (value.newOwner,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for transferOwnershipCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { newOwner: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: transferOwnershipReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for transferOwnershipReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl transferOwnershipReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for transferOwnershipCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = transferOwnershipReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transferOwnership(address)"; + const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::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 { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + ///Container for all the [`DummyShoeBillToken`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum DummyShoeBillTokenCalls { + #[allow(missing_docs)] + allowance(allowanceCall), + #[allow(missing_docs)] + approve(approveCall), + #[allow(missing_docs)] + balanceOf(balanceOfCall), + #[allow(missing_docs)] + balanceOfUnderlying(balanceOfUnderlyingCall), + #[allow(missing_docs)] + decimals(decimalsCall), + #[allow(missing_docs)] + decreaseAllowance(decreaseAllowanceCall), + #[allow(missing_docs)] + increaseAllowance(increaseAllowanceCall), + #[allow(missing_docs)] + mint(mintCall), + #[allow(missing_docs)] + name(nameCall), + #[allow(missing_docs)] + owner(ownerCall), + #[allow(missing_docs)] + renounceOwnership(renounceOwnershipCall), + #[allow(missing_docs)] + sudoMint(sudoMintCall), + #[allow(missing_docs)] + symbol(symbolCall), + #[allow(missing_docs)] + totalSupply(totalSupplyCall), + #[allow(missing_docs)] + transfer(transferCall), + #[allow(missing_docs)] + transferFrom(transferFromCall), + #[allow(missing_docs)] + transferOwnership(transferOwnershipCall), + } + #[automatically_derived] + impl DummyShoeBillTokenCalls { + /// 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], + [45u8, 104u8, 140u8, 168u8], + [49u8, 60u8, 229u8, 103u8], + [57u8, 80u8, 147u8, 81u8], + [58u8, 249u8, 230u8, 105u8], + [112u8, 160u8, 130u8, 49u8], + [113u8, 80u8, 24u8, 166u8], + [141u8, 165u8, 203u8, 91u8], + [149u8, 216u8, 155u8, 65u8], + [160u8, 113u8, 45u8, 104u8], + [164u8, 87u8, 194u8, 215u8], + [169u8, 5u8, 156u8, 187u8], + [221u8, 98u8, 237u8, 62u8], + [242u8, 253u8, 227u8, 139u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for DummyShoeBillTokenCalls { + const NAME: &'static str = "DummyShoeBillTokenCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 17usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::allowance(_) => { + ::SELECTOR + } + Self::approve(_) => ::SELECTOR, + Self::balanceOf(_) => { + ::SELECTOR + } + Self::balanceOfUnderlying(_) => { + ::SELECTOR + } + Self::decimals(_) => ::SELECTOR, + Self::decreaseAllowance(_) => { + ::SELECTOR + } + Self::increaseAllowance(_) => { + ::SELECTOR + } + Self::mint(_) => ::SELECTOR, + Self::name(_) => ::SELECTOR, + Self::owner(_) => ::SELECTOR, + Self::renounceOwnership(_) => { + ::SELECTOR + } + Self::sudoMint(_) => ::SELECTOR, + Self::symbol(_) => ::SELECTOR, + Self::totalSupply(_) => { + ::SELECTOR + } + Self::transfer(_) => ::SELECTOR, + Self::transferFrom(_) => { + ::SELECTOR + } + Self::transferOwnership(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn name( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyShoeBillTokenCalls::name) + } + name + }, + { + fn approve( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyShoeBillTokenCalls::approve) + } + approve + }, + { + fn totalSupply( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummyShoeBillTokenCalls::totalSupply) + } + totalSupply + }, + { + fn transferFrom( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummyShoeBillTokenCalls::transferFrom) + } + transferFrom + }, + { + fn sudoMint( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyShoeBillTokenCalls::sudoMint) + } + sudoMint + }, + { + fn decimals( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyShoeBillTokenCalls::decimals) + } + decimals + }, + { + fn increaseAllowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummyShoeBillTokenCalls::increaseAllowance) + } + increaseAllowance + }, + { + fn balanceOfUnderlying( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummyShoeBillTokenCalls::balanceOfUnderlying) + } + balanceOfUnderlying + }, + { + fn balanceOf( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyShoeBillTokenCalls::balanceOf) + } + balanceOf + }, + { + fn renounceOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummyShoeBillTokenCalls::renounceOwnership) + } + renounceOwnership + }, + { + fn owner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyShoeBillTokenCalls::owner) + } + owner + }, + { + fn symbol( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyShoeBillTokenCalls::symbol) + } + symbol + }, + { + fn mint( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyShoeBillTokenCalls::mint) + } + mint + }, + { + fn decreaseAllowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummyShoeBillTokenCalls::decreaseAllowance) + } + decreaseAllowance + }, + { + fn transfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyShoeBillTokenCalls::transfer) + } + transfer + }, + { + fn allowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(DummyShoeBillTokenCalls::allowance) + } + allowance + }, + { + fn transferOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummyShoeBillTokenCalls::transferOwnership) + } + transferOwnership + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn name( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyShoeBillTokenCalls::name) + } + name + }, + { + fn approve( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyShoeBillTokenCalls::approve) + } + approve + }, + { + fn totalSupply( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyShoeBillTokenCalls::totalSupply) + } + totalSupply + }, + { + fn transferFrom( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyShoeBillTokenCalls::transferFrom) + } + transferFrom + }, + { + fn sudoMint( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyShoeBillTokenCalls::sudoMint) + } + sudoMint + }, + { + fn decimals( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyShoeBillTokenCalls::decimals) + } + decimals + }, + { + fn increaseAllowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyShoeBillTokenCalls::increaseAllowance) + } + increaseAllowance + }, + { + fn balanceOfUnderlying( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyShoeBillTokenCalls::balanceOfUnderlying) + } + balanceOfUnderlying + }, + { + fn balanceOf( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyShoeBillTokenCalls::balanceOf) + } + balanceOf + }, + { + fn renounceOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyShoeBillTokenCalls::renounceOwnership) + } + renounceOwnership + }, + { + fn owner( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyShoeBillTokenCalls::owner) + } + owner + }, + { + fn symbol( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyShoeBillTokenCalls::symbol) + } + symbol + }, + { + fn mint( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyShoeBillTokenCalls::mint) + } + mint + }, + { + fn decreaseAllowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyShoeBillTokenCalls::decreaseAllowance) + } + decreaseAllowance + }, + { + fn transfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyShoeBillTokenCalls::transfer) + } + transfer + }, + { + fn allowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyShoeBillTokenCalls::allowance) + } + allowance + }, + { + fn transferOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummyShoeBillTokenCalls::transferOwnership) + } + transferOwnership + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::allowance(inner) => { + ::abi_encoded_size(inner) + } + Self::approve(inner) => { + ::abi_encoded_size(inner) + } + Self::balanceOf(inner) => { + ::abi_encoded_size(inner) + } + Self::balanceOfUnderlying(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::decimals(inner) => { + ::abi_encoded_size(inner) + } + Self::decreaseAllowance(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::increaseAllowance(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::mint(inner) => { + ::abi_encoded_size(inner) + } + Self::name(inner) => { + ::abi_encoded_size(inner) + } + Self::owner(inner) => { + ::abi_encoded_size(inner) + } + Self::renounceOwnership(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::sudoMint(inner) => { + ::abi_encoded_size(inner) + } + Self::symbol(inner) => { + ::abi_encoded_size(inner) + } + Self::totalSupply(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::transfer(inner) => { + ::abi_encoded_size(inner) + } + Self::transferFrom(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::transferOwnership(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::allowance(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::approve(inner) => { + ::abi_encode_raw(inner, out) + } + Self::balanceOf(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::balanceOfUnderlying(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::decimals(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::decreaseAllowance(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::increaseAllowance(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::mint(inner) => { + ::abi_encode_raw(inner, out) + } + Self::name(inner) => { + ::abi_encode_raw(inner, out) + } + Self::owner(inner) => { + ::abi_encode_raw(inner, out) + } + Self::renounceOwnership(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::sudoMint(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::symbol(inner) => { + ::abi_encode_raw(inner, out) + } + Self::totalSupply(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transfer(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transferFrom(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transferOwnership(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`DummyShoeBillToken`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum DummyShoeBillTokenEvents { + #[allow(missing_docs)] + Approval(Approval), + #[allow(missing_docs)] + OwnershipTransferred(OwnershipTransferred), + #[allow(missing_docs)] + Transfer(Transfer), + } + #[automatically_derived] + impl DummyShoeBillTokenEvents { + /// 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]] = &[ + [ + 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, 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, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for DummyShoeBillTokenEvents { + const NAME: &'static str = "DummyShoeBillTokenEvents"; + const COUNT: usize = 3usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Approval) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::OwnershipTransferred) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Transfer) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 DummyShoeBillTokenEvents { + 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::OwnershipTransferred(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::OwnershipTransferred(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 as alloy_contract; + /**Creates a new wrapper around an on-chain [`DummyShoeBillToken`](self) contract instance. + +See the [wrapper's documentation](`DummyShoeBillTokenInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> DummyShoeBillTokenInstance { + DummyShoeBillTokenInstance::::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: alloy_contract::private::Network, + >( + provider: P, + name_: alloy::sol_types::private::String, + symbol_: alloy::sol_types::private::String, + _doMint: bool, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + DummyShoeBillTokenInstance::::deploy(provider, name_, symbol_, _doMint) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + name_: alloy::sol_types::private::String, + symbol_: alloy::sol_types::private::String, + _doMint: bool, + ) -> alloy_contract::RawCallBuilder { + DummyShoeBillTokenInstance::< + P, + N, + >::deploy_builder(provider, name_, symbol_, _doMint) + } + /**A [`DummyShoeBillToken`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`DummyShoeBillToken`](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 DummyShoeBillTokenInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for DummyShoeBillTokenInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("DummyShoeBillTokenInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummyShoeBillTokenInstance { + /**Creates a new wrapper around an on-chain [`DummyShoeBillToken`](self) contract instance. + +See the [wrapper's documentation](`DummyShoeBillTokenInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + name_: alloy::sol_types::private::String, + symbol_: alloy::sol_types::private::String, + _doMint: bool, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(provider, name_, symbol_, _doMint); + 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, + name_: alloy::sol_types::private::String, + symbol_: alloy::sol_types::private::String, + _doMint: bool, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + name_, + symbol_, + _doMint, + }, + )[..], + ] + .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 DummyShoeBillTokenInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> DummyShoeBillTokenInstance { + DummyShoeBillTokenInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummyShoeBillTokenInstance { + /// 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( + &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 [`balanceOfUnderlying`] function. + pub fn balanceOfUnderlying( + &self, + _0: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, balanceOfUnderlyingCall, N> { + self.call_builder(&balanceOfUnderlyingCall(_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 [`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 [`mint`] function. + pub fn mint( + &self, + mintAmount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> { + self.call_builder(&mintCall { mintAmount }) + } + ///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 [`renounceOwnership`] function. + pub fn renounceOwnership( + &self, + ) -> alloy_contract::SolCallBuilder<&P, renounceOwnershipCall, N> { + self.call_builder(&renounceOwnershipCall) + } + ///Creates a new call builder for the [`sudoMint`] function. + pub fn sudoMint( + &self, + to: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, sudoMintCall, N> { + self.call_builder(&sudoMintCall { to, amount }) + } + ///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, + 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, + }, + ) + } + ///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. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummyShoeBillTokenInstance { + /// 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( + &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::() + } + ///Creates a new event filter for the [`OwnershipTransferred`] event. + pub fn OwnershipTransferred_filter( + &self, + ) -> alloy_contract::Event<&P, OwnershipTransferred, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`Transfer`] event. + pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/dummy_solv_router.rs b/crates/bindings/src/dummy_solv_router.rs new file mode 100644 index 000000000..e83bdf8b0 --- /dev/null +++ b/crates/bindings/src/dummy_solv_router.rs @@ -0,0 +1,679 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface DummySolvRouter { + constructor(bool _doTransferAmount, address _solvBTC); + + function createSubscription(bytes32, uint256 amount) external returns (uint256 shareValue); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_doTransferAmount", + "type": "bool", + "internalType": "bool" + }, + { + "name": "_solvBTC", + "type": "address", + "internalType": "contract ArbitaryErc20" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "createSubscription", + "inputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "shareValue", + "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 DummySolvRouter { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x6080604052348015600e575f5ffd5b5060405161023b38038061023b833981016040819052602b916064565b5f80546001600160a81b031916921515610100600160a81b031916929092176101006001600160a01b03929092169190910217905560a8565b5f5f604083850312156074575f5ffd5b825180151581146082575f5ffd5b60208401519092506001600160a01b0381168114609d575f5ffd5b809150509250929050565b610186806100b55f395ff3fe608060405234801561000f575f5ffd5b5060043610610029575f3560e01c80636d724ead1461002d575b5f5ffd5b61004061003b36600461010a565b610052565b60405190815260200160405180910390f35b5f805460ff1615610101575f546040517fa9059cbb0000000000000000000000000000000000000000000000000000000081523360048201526024810184905261010090910473ffffffffffffffffffffffffffffffffffffffff169063a9059cbb906044016020604051808303815f875af11580156100d4573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100f8919061012a565b50819050610104565b505f5b92915050565b5f5f6040838503121561011b575f5ffd5b50508035926020909101359150565b5f6020828403121561013a575f5ffd5b81518015158114610149575f5ffd5b939250505056fea264697066735822122043ca8c40391d178cae39779fe416a994c745d87dbd970c735590c0a6c88399c064736f6c634300081c0033 + /// ``` + #[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`@Qa\x02;8\x03\x80a\x02;\x839\x81\x01`@\x81\x90R`+\x91`dV[_\x80T`\x01`\x01`\xA8\x1B\x03\x19\x16\x92\x15\x15a\x01\0`\x01`\xA8\x1B\x03\x19\x16\x92\x90\x92\x17a\x01\0`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x02\x17\x90U`\xA8V[__`@\x83\x85\x03\x12\x15`tW__\xFD[\x82Q\x80\x15\x15\x81\x14`\x82W__\xFD[` \x84\x01Q\x90\x92P`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14`\x9DW__\xFD[\x80\x91PP\x92P\x92\x90PV[a\x01\x86\x80a\0\xB5_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0)W_5`\xE0\x1C\x80cmrN\xAD\x14a\0-W[__\xFD[a\0@a\0;6`\x04a\x01\nV[a\0RV[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[_\x80T`\xFF\x16\x15a\x01\x01W_T`@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\x81R3`\x04\x82\x01R`$\x81\x01\x84\x90Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90c\xA9\x05\x9C\xBB\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\0\xD4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\0\xF8\x91\x90a\x01*V[P\x81\x90Pa\x01\x04V[P_[\x92\x91PPV[__`@\x83\x85\x03\x12\x15a\x01\x1BW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x01:W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x01IW__\xFD[\x93\x92PPPV\xFE\xA2dipfsX\"\x12 C\xCA\x8C@9\x1D\x17\x8C\xAE9w\x9F\xE4\x16\xA9\x94\xC7E\xD8}\xBD\x97\x0CsU\x90\xC0\xA6\xC8\x83\x99\xC0dsolcC\0\x08\x1C\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x608060405234801561000f575f5ffd5b5060043610610029575f3560e01c80636d724ead1461002d575b5f5ffd5b61004061003b36600461010a565b610052565b60405190815260200160405180910390f35b5f805460ff1615610101575f546040517fa9059cbb0000000000000000000000000000000000000000000000000000000081523360048201526024810184905261010090910473ffffffffffffffffffffffffffffffffffffffff169063a9059cbb906044016020604051808303815f875af11580156100d4573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100f8919061012a565b50819050610104565b505f5b92915050565b5f5f6040838503121561011b575f5ffd5b50508035926020909101359150565b5f6020828403121561013a575f5ffd5b81518015158114610149575f5ffd5b939250505056fea264697066735822122043ca8c40391d178cae39779fe416a994c745d87dbd970c735590c0a6c88399c064736f6c634300081c0033 + /// ``` + #[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\x80cmrN\xAD\x14a\0-W[__\xFD[a\0@a\0;6`\x04a\x01\nV[a\0RV[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[_\x80T`\xFF\x16\x15a\x01\x01W_T`@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\x81R3`\x04\x82\x01R`$\x81\x01\x84\x90Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90c\xA9\x05\x9C\xBB\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\0\xD4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\0\xF8\x91\x90a\x01*V[P\x81\x90Pa\x01\x04V[P_[\x92\x91PPV[__`@\x83\x85\x03\x12\x15a\x01\x1BW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x01:W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x01IW__\xFD[\x93\x92PPPV\xFE\xA2dipfsX\"\x12 C\xCA\x8C@9\x1D\x17\x8C\xAE9w\x9F\xE4\x16\xA9\x94\xC7E\xD8}\xBD\x97\x0CsU\x90\xC0\xA6\xC8\x83\x99\xC0dsolcC\0\x08\x1C\x003", + ); + /**Constructor`. +```solidity +constructor(bool _doTransferAmount, address _solvBTC); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _doTransferAmount: bool, + #[allow(missing_docs)] + pub _solvBTC: alloy::sol_types::private::Address, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Bool, + alloy::sol_types::sol_data::Address, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (bool, alloy::sol_types::private::Address); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._doTransferAmount, value._solvBTC) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _doTransferAmount: tuple.0, + _solvBTC: tuple.1, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolConstructor for constructorCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Bool, + alloy::sol_types::sol_data::Address, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._doTransferAmount, + ), + ::tokenize( + &self._solvBTC, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `createSubscription(bytes32,uint256)` and selector `0x6d724ead`. +```solidity +function createSubscription(bytes32, uint256 amount) external returns (uint256 shareValue); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct createSubscriptionCall { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub amount: alloy::sol_types::private::primitives::aliases::U256, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`createSubscription(bytes32,uint256)`](createSubscriptionCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct createSubscriptionReturn { + #[allow(missing_docs)] + pub shareValue: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: createSubscriptionCall) -> Self { + (value._0, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for createSubscriptionCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _0: tuple.0, + amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: createSubscriptionReturn) -> Self { + (value.shareValue,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for createSubscriptionReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { shareValue: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for createSubscriptionCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "createSubscription(bytes32,uint256)"; + const SELECTOR: [u8; 4] = [109u8, 114u8, 78u8, 173u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: createSubscriptionReturn = r.into(); + r.shareValue + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: createSubscriptionReturn = r.into(); + r.shareValue + }) + } + } + }; + ///Container for all the [`DummySolvRouter`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum DummySolvRouterCalls { + #[allow(missing_docs)] + createSubscription(createSubscriptionCall), + } + #[automatically_derived] + impl DummySolvRouterCalls { + /// 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]] = &[[109u8, 114u8, 78u8, 173u8]]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for DummySolvRouterCalls { + const NAME: &'static str = "DummySolvRouterCalls"; + const MIN_DATA_LENGTH: usize = 64usize; + const COUNT: usize = 1usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::createSubscription(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn createSubscription( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(DummySolvRouterCalls::createSubscription) + } + createSubscription + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn createSubscription( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(DummySolvRouterCalls::createSubscription) + } + createSubscription + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::createSubscription(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::createSubscription(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`DummySolvRouter`](self) contract instance. + +See the [wrapper's documentation](`DummySolvRouterInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> DummySolvRouterInstance { + DummySolvRouterInstance::::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: alloy_contract::private::Network, + >( + provider: P, + _doTransferAmount: bool, + _solvBTC: alloy::sol_types::private::Address, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + DummySolvRouterInstance::::deploy(provider, _doTransferAmount, _solvBTC) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + _doTransferAmount: bool, + _solvBTC: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + DummySolvRouterInstance::< + P, + N, + >::deploy_builder(provider, _doTransferAmount, _solvBTC) + } + /**A [`DummySolvRouter`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`DummySolvRouter`](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 DummySolvRouterInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for DummySolvRouterInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("DummySolvRouterInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummySolvRouterInstance { + /**Creates a new wrapper around an on-chain [`DummySolvRouter`](self) contract instance. + +See the [wrapper's documentation](`DummySolvRouterInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + _doTransferAmount: bool, + _solvBTC: alloy::sol_types::private::Address, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder( + provider, + _doTransferAmount, + _solvBTC, + ); + 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, + _doTransferAmount: bool, + _solvBTC: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + _doTransferAmount, + _solvBTC, + }, + )[..], + ] + .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 DummySolvRouterInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> DummySolvRouterInstance { + DummySolvRouterInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummySolvRouterInstance { + /// 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( + &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 [`createSubscription`] function. + pub fn createSubscription( + &self, + _0: alloy::sol_types::private::FixedBytes<32>, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, createSubscriptionCall, N> { + self.call_builder( + &createSubscriptionCall { + _0, + amount, + }, + ) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > DummySolvRouterInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/erc20.rs b/crates/bindings/src/erc20.rs new file mode 100644 index 000000000..1286d9747 --- /dev/null +++ b/crates/bindings/src/erc20.rs @@ -0,0 +1,3224 @@ +/** + +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 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": "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": "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" + }, + { + "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::*; + use alloy::sol_types as 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__\xFD[P`@Qa\r\x0C8\x03\x80a\r\x0C\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\xECV[`\x03a\0:\x83\x82a\x01\xD5V[P`\x04a\0G\x82\x82a\x01\xD5V[PPPa\x02\x8FV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x82`\x1F\x83\x01\x12a\0rW__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\0\x8BWa\0\x8Ba\0OV[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\0\xB9Wa\0\xB9a\0OV[`@R\x81\x81R\x83\x82\x01` \x01\x85\x10\x15a\0\xD0W__\xFD[\x81` \x85\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[__`@\x83\x85\x03\x12\x15a\0\xFDW__\xFD[\x82Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\x12W__\xFD[a\x01\x1E\x85\x82\x86\x01a\0cV[` \x85\x01Q\x90\x93P\x90P`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01;W__\xFD[a\x01G\x85\x82\x86\x01a\0cV[\x91PP\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x01eW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x01\x83WcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\x01\xD0W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x01\xAEWP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x01\xCDW_\x81U`\x01\x01a\x01\xBAV[PP[PPPV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\xEEWa\x01\xEEa\0OV[a\x02\x02\x81a\x01\xFC\x84Ta\x01QV[\x84a\x01\x89V[` `\x1F\x82\x11`\x01\x81\x14a\x024W_\x83\x15a\x02\x1DWP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x01\xCDV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x02cW\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x02CV[P\x84\x82\x10\x15a\x02\x80W\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[a\np\x80a\x02\x9C_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xC4W_5`\xE0\x1C\x80c9P\x93Q\x11a\0}W\x80c\xA4W\xC2\xD7\x11a\0XW\x80c\xA4W\xC2\xD7\x14a\x01\x8DW\x80c\xA9\x05\x9C\xBB\x14a\x01\xA0W\x80c\xDDb\xED>\x14a\x01\xB3W__\xFD[\x80c9P\x93Q\x14a\x01=W\x80cp\xA0\x821\x14a\x01PW\x80c\x95\xD8\x9BA\x14a\x01\x85W__\xFD[\x80c\x18\x16\r\xDD\x11a\0\xADW\x80c\x18\x16\r\xDD\x14a\x01\tW\x80c#\xB8r\xDD\x14a\x01\x1BW\x80c1<\xE5g\x14a\x01.W__\xFD[\x80c\x06\xFD\xDE\x03\x14a\0\xC8W\x80c\t^\xA7\xB3\x14a\0\xE6W[__\xFD[a\0\xD0a\x01\xF8V[`@Qa\0\xDD\x91\x90a\x08\x83V[`@Q\x80\x91\x03\x90\xF3[a\0\xF9a\0\xF46`\x04a\x08\xFEV[a\x02\x88V[`@Q\x90\x15\x15\x81R` \x01a\0\xDDV[`\x02T[`@Q\x90\x81R` \x01a\0\xDDV[a\0\xF9a\x01)6`\x04a\t&V[a\x02\xA1V[`@Q`\x12\x81R` \x01a\0\xDDV[a\0\xF9a\x01K6`\x04a\x08\xFEV[a\x02\xC4V[a\x01\ra\x01^6`\x04a\t`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 T\x90V[a\0\xD0a\x03\x0FV[a\0\xF9a\x01\x9B6`\x04a\x08\xFEV[a\x03\x1EV[a\0\xF9a\x01\xAE6`\x04a\x08\xFEV[a\x03\xD9V[a\x01\ra\x01\xC16`\x04a\t\x80V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x91\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[```\x03\x80Ta\x02\x07\x90a\t\xB1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x023\x90a\t\xB1V[\x80\x15a\x02~W\x80`\x1F\x10a\x02UWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02~V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02aW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[_3a\x02\x95\x81\x85\x85a\x03\xE6V[`\x01\x91PP[\x92\x91PPV[_3a\x02\xAE\x85\x82\x85a\x05dV[a\x02\xB9\x85\x85\x85a\x06 V[P`\x01\x94\x93PPPPV[3_\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\x91\x90a\x02\x95\x90\x82\x90\x86\x90a\x03\n\x90\x87\x90a\n\x02V[a\x03\xE6V[```\x04\x80Ta\x02\x07\x90a\t\xB1V[3_\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\x91\x90\x83\x81\x10\x15a\x03\xCCW`@QbF\x1B\xCD`\xE5\x1B\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\x01[`@Q\x80\x91\x03\x90\xFD[a\x02\xB9\x82\x86\x86\x84\x03a\x03\xE6V[_3a\x02\x95\x81\x85\x85a\x06 V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16a\x04nW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC3V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16a\x04\xF7W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC3V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x81\x16_\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\x81\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R 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\x81\x14a\x06\x1AW\x81\x81\x10\x15a\x06\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FERC20: insufficient allowance\0\0\0`D\x82\x01R`d\x01a\x03\xC3V[a\x06\x1A\x84\x84\x84\x84\x03a\x03\xE6V[PPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16a\x06\xA9W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC3V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16a\x072W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC3V[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 T\x81\x81\x10\x15a\x07\xCDW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC3V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16_\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R\x90\x81 \x80T\x84\x92\x90a\x08\x10\x90\x84\x90a\n\x02V[\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\x08v\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3a\x06\x1AV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\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\x84\x01\x01\x91PP\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\x08\xF9W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\t\x0FW__\xFD[a\t\x18\x83a\x08\xD6V[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\t8W__\xFD[a\tA\x84a\x08\xD6V[\x92Pa\tO` \x85\x01a\x08\xD6V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\tpW__\xFD[a\ty\x82a\x08\xD6V[\x93\x92PPPV[__`@\x83\x85\x03\x12\x15a\t\x91W__\xFD[a\t\x9A\x83a\x08\xD6V[\x91Pa\t\xA8` \x84\x01a\x08\xD6V[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\t\xC5W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\t\xFCW\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[P\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02\x9BW\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\xFE\xA2dipfsX\"\x12 \x80\x1A\x0B]\xB9\xB4\x9B\xDA\xD7~\x05HH\xEE\"\xCB\x0F\x91\xE2\xE3`\x06\xC4g\x94#2\x17\xFD\xF6\xFA,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\0\xC4W_5`\xE0\x1C\x80c9P\x93Q\x11a\0}W\x80c\xA4W\xC2\xD7\x11a\0XW\x80c\xA4W\xC2\xD7\x14a\x01\x8DW\x80c\xA9\x05\x9C\xBB\x14a\x01\xA0W\x80c\xDDb\xED>\x14a\x01\xB3W__\xFD[\x80c9P\x93Q\x14a\x01=W\x80cp\xA0\x821\x14a\x01PW\x80c\x95\xD8\x9BA\x14a\x01\x85W__\xFD[\x80c\x18\x16\r\xDD\x11a\0\xADW\x80c\x18\x16\r\xDD\x14a\x01\tW\x80c#\xB8r\xDD\x14a\x01\x1BW\x80c1<\xE5g\x14a\x01.W__\xFD[\x80c\x06\xFD\xDE\x03\x14a\0\xC8W\x80c\t^\xA7\xB3\x14a\0\xE6W[__\xFD[a\0\xD0a\x01\xF8V[`@Qa\0\xDD\x91\x90a\x08\x83V[`@Q\x80\x91\x03\x90\xF3[a\0\xF9a\0\xF46`\x04a\x08\xFEV[a\x02\x88V[`@Q\x90\x15\x15\x81R` \x01a\0\xDDV[`\x02T[`@Q\x90\x81R` \x01a\0\xDDV[a\0\xF9a\x01)6`\x04a\t&V[a\x02\xA1V[`@Q`\x12\x81R` \x01a\0\xDDV[a\0\xF9a\x01K6`\x04a\x08\xFEV[a\x02\xC4V[a\x01\ra\x01^6`\x04a\t`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 T\x90V[a\0\xD0a\x03\x0FV[a\0\xF9a\x01\x9B6`\x04a\x08\xFEV[a\x03\x1EV[a\0\xF9a\x01\xAE6`\x04a\x08\xFEV[a\x03\xD9V[a\x01\ra\x01\xC16`\x04a\t\x80V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x91\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[```\x03\x80Ta\x02\x07\x90a\t\xB1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x023\x90a\t\xB1V[\x80\x15a\x02~W\x80`\x1F\x10a\x02UWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02~V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02aW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[_3a\x02\x95\x81\x85\x85a\x03\xE6V[`\x01\x91PP[\x92\x91PPV[_3a\x02\xAE\x85\x82\x85a\x05dV[a\x02\xB9\x85\x85\x85a\x06 V[P`\x01\x94\x93PPPPV[3_\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\x91\x90a\x02\x95\x90\x82\x90\x86\x90a\x03\n\x90\x87\x90a\n\x02V[a\x03\xE6V[```\x04\x80Ta\x02\x07\x90a\t\xB1V[3_\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\x91\x90\x83\x81\x10\x15a\x03\xCCW`@QbF\x1B\xCD`\xE5\x1B\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\x01[`@Q\x80\x91\x03\x90\xFD[a\x02\xB9\x82\x86\x86\x84\x03a\x03\xE6V[_3a\x02\x95\x81\x85\x85a\x06 V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16a\x04nW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC3V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16a\x04\xF7W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC3V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x81\x16_\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\x81\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R 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\x81\x14a\x06\x1AW\x81\x81\x10\x15a\x06\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FERC20: insufficient allowance\0\0\0`D\x82\x01R`d\x01a\x03\xC3V[a\x06\x1A\x84\x84\x84\x84\x03a\x03\xE6V[PPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16a\x06\xA9W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC3V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16a\x072W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC3V[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 T\x81\x81\x10\x15a\x07\xCDW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC3V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16_\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R\x90\x81 \x80T\x84\x92\x90a\x08\x10\x90\x84\x90a\n\x02V[\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\x08v\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3a\x06\x1AV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\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\x84\x01\x01\x91PP\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\x08\xF9W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\t\x0FW__\xFD[a\t\x18\x83a\x08\xD6V[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\t8W__\xFD[a\tA\x84a\x08\xD6V[\x92Pa\tO` \x85\x01a\x08\xD6V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\tpW__\xFD[a\ty\x82a\x08\xD6V[\x93\x92PPPV[__`@\x83\x85\x03\x12\x15a\t\x91W__\xFD[a\t\x9A\x83a\x08\xD6V[\x91Pa\t\xA8` \x84\x01a\x08\xD6V[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\t\xC5W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\t\xFCW\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[P\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02\x9BW\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\xFE\xA2dipfsX\"\x12 \x80\x1A\x0B]\xB9\xB4\x9B\xDA\xD7~\x05HH\xEE\"\xCB\x0F\x91\xE2\xE3`\x06\xC4g\x94#2\x17\xFD\xF6\xFA,dsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Approval { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + 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, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + owner: topics.1, + spender: topics.2, + value: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.value), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.owner, + ); + out[2usize] = ::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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Transfer { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + 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, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + from: topics.1, + to: topics.2, + value: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.value), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.from, + ); + out[2usize] = ::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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value.name_, value.symbol_) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.name_, + ), + ::tokenize( + &self.symbol_, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: allowanceCall) -> Self { + (value.owner, value.spender) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for allowanceCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + owner: tuple.0, + spender: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: allowanceReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "allowance(address,address)"; + const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.owner, + ), + ::tokenize( + &self.spender, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: allowanceReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: approveCall) -> Self { + (value.spender, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for approveCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + spender: tuple.0, + amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: approveReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "approve(address,uint256)"; + const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.spender, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: approveReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: balanceOfCall) -> Self { + (value.account,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for balanceOfCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { account: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: balanceOfReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "balanceOf(address)"; + const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.account, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: balanceOfReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: decimalsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for decimalsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: decimalsReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for decimalsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for decimalsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = u8; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "decimals()"; + const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: decimalsReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: decreaseAllowanceCall) -> Self { + (value.spender, value.subtractedValue) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for decreaseAllowanceCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + spender: tuple.0, + subtractedValue: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: decreaseAllowanceReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)"; + const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.spender, + ), + as alloy_sol_types::SolType>::tokenize(&self.subtractedValue), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: decreaseAllowanceReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: increaseAllowanceCall) -> Self { + (value.spender, value.addedValue) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for increaseAllowanceCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + spender: tuple.0, + addedValue: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: increaseAllowanceReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "increaseAllowance(address,uint256)"; + const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.spender, + ), + as alloy_sol_types::SolType>::tokenize(&self.addedValue), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: increaseAllowanceReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: nameCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for nameCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: nameReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for nameReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for nameCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::String; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "name()"; + const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: nameReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: symbolCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for symbolCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: symbolReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for symbolReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for symbolCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::String; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "symbol()"; + const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: symbolReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: totalSupplyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for totalSupplyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: totalSupplyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for totalSupplyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for totalSupplyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "totalSupply()"; + const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: totalSupplyReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferCall) -> Self { + (value.to, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for transferCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + to: tuple.0, + amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transfer(address,uint256)"; + const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.to, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: transferReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferFromCall) -> Self { + (value.from, value.to, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for transferFromCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + from: tuple.0, + to: tuple.1, + amount: tuple.2, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferFromReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transferFrom(address,address,uint256)"; + const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.from, + ), + ::tokenize( + &self.to, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + 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(serde::Serialize, serde::Deserialize)] + #[derive()] + 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), + } + #[automatically_derived] + 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], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for ERC20Calls { + const NAME: &'static str = "ERC20Calls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 11usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::allowance(_) => { + ::SELECTOR + } + Self::approve(_) => ::SELECTOR, + Self::balanceOf(_) => { + ::SELECTOR + } + Self::decimals(_) => ::SELECTOR, + Self::decreaseAllowance(_) => { + ::SELECTOR + } + Self::increaseAllowance(_) => { + ::SELECTOR + } + Self::name(_) => ::SELECTOR, + Self::symbol(_) => ::SELECTOR, + Self::totalSupply(_) => { + ::SELECTOR + } + Self::transfer(_) => ::SELECTOR, + Self::transferFrom(_) => { + ::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 { + static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result] = &[ + { + fn name(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ERC20Calls::name) + } + name + }, + { + fn approve(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ERC20Calls::approve) + } + approve + }, + { + fn totalSupply(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ERC20Calls::totalSupply) + } + totalSupply + }, + { + fn transferFrom(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ERC20Calls::transferFrom) + } + transferFrom + }, + { + fn decimals(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ERC20Calls::decimals) + } + decimals + }, + { + fn increaseAllowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ERC20Calls::increaseAllowance) + } + increaseAllowance + }, + { + fn balanceOf(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ERC20Calls::balanceOf) + } + balanceOf + }, + { + fn symbol(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ERC20Calls::symbol) + } + symbol + }, + { + fn decreaseAllowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ERC20Calls::decreaseAllowance) + } + decreaseAllowance + }, + { + fn transfer(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ERC20Calls::transfer) + } + transfer + }, + { + fn allowance(data: &[u8]) -> alloy_sol_types::Result { + ::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( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn name(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ERC20Calls::name) + } + name + }, + { + fn approve(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ERC20Calls::approve) + } + approve + }, + { + fn totalSupply(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ERC20Calls::totalSupply) + } + totalSupply + }, + { + fn transferFrom(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ERC20Calls::transferFrom) + } + transferFrom + }, + { + fn decimals(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ERC20Calls::decimals) + } + decimals + }, + { + fn increaseAllowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ERC20Calls::increaseAllowance) + } + increaseAllowance + }, + { + fn balanceOf(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ERC20Calls::balanceOf) + } + balanceOf + }, + { + fn symbol(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ERC20Calls::symbol) + } + symbol + }, + { + fn decreaseAllowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ERC20Calls::decreaseAllowance) + } + decreaseAllowance + }, + { + fn transfer(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ERC20Calls::transfer) + } + transfer + }, + { + fn allowance(data: &[u8]) -> alloy_sol_types::Result { + ::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( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::allowance(inner) => { + ::abi_encoded_size(inner) + } + Self::approve(inner) => { + ::abi_encoded_size(inner) + } + Self::balanceOf(inner) => { + ::abi_encoded_size(inner) + } + Self::decimals(inner) => { + ::abi_encoded_size(inner) + } + Self::decreaseAllowance(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::increaseAllowance(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::name(inner) => { + ::abi_encoded_size(inner) + } + Self::symbol(inner) => { + ::abi_encoded_size(inner) + } + Self::totalSupply(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::transfer(inner) => { + ::abi_encoded_size(inner) + } + Self::transferFrom(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::allowance(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::approve(inner) => { + ::abi_encode_raw(inner, out) + } + Self::balanceOf(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::decimals(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::decreaseAllowance(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::increaseAllowance(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::name(inner) => { + ::abi_encode_raw(inner, out) + } + Self::symbol(inner) => { + ::abi_encode_raw(inner, out) + } + Self::totalSupply(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transfer(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transferFrom(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`ERC20`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum ERC20Events { + #[allow(missing_docs)] + Approval(Approval), + #[allow(missing_docs)] + Transfer(Transfer), + } + #[automatically_derived] + 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, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for ERC20Events { + const NAME: &'static str = "ERC20Events"; + const COUNT: usize = 2usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Approval) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Transfer) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 as 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: alloy_contract::private::Network, + >(address: alloy_sol_types::private::Address, provider: P) -> ERC20Instance { + ERC20Instance::::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: alloy_contract::private::Network, + >( + provider: P, + name_: alloy::sol_types::private::String, + symbol_: alloy::sol_types::private::String, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + ERC20Instance::::deploy(provider, name_, symbol_) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + name_: alloy::sol_types::private::String, + symbol_: alloy::sol_types::private::String, + ) -> alloy_contract::RawCallBuilder { + ERC20Instance::::deploy_builder(provider, name_, symbol_) + } + /**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 { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for ERC20Instance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("ERC20Instance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ERC20Instance { + /**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, + _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, + name_: alloy::sol_types::private::String, + symbol_: alloy::sol_types::private::String, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(provider, name_, symbol_); + 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, + name_: alloy::sol_types::private::String, + symbol_: alloy::sol_types::private::String, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { name_, symbol_ }, + )[..], + ] + .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 ERC20Instance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> ERC20Instance { + ERC20Instance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ERC20Instance { + /// 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( + &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, + 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. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ERC20Instance { + /// 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( + &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::() + } + ///Creates a new event filter for the [`Transfer`] event. + pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/erc2771_recipient.rs b/crates/bindings/src/erc2771_recipient.rs new file mode 100644 index 000000000..42aeadf67 --- /dev/null +++ b/crates/bindings/src/erc2771_recipient.rs @@ -0,0 +1,735 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface ERC2771Recipient { + function getTrustedForwarder() external view returns (address forwarder); + function isTrustedForwarder(address forwarder) external view returns (bool); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "getTrustedForwarder", + "inputs": [], + "outputs": [ + { + "name": "forwarder", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isTrustedForwarder", + "inputs": [ + { + "name": "forwarder", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + } +] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod ERC2771Recipient { + use super::*; + use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `getTrustedForwarder()` and selector `0xce1b815f`. +```solidity +function getTrustedForwarder() external view returns (address forwarder); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getTrustedForwarderCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`getTrustedForwarder()`](getTrustedForwarderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getTrustedForwarderReturn { + #[allow(missing_docs)] + pub forwarder: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getTrustedForwarderCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getTrustedForwarderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getTrustedForwarderReturn) -> Self { + (value.forwarder,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getTrustedForwarderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { forwarder: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getTrustedForwarderCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getTrustedForwarder()"; + const SELECTOR: [u8; 4] = [206u8, 27u8, 129u8, 95u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: getTrustedForwarderReturn = r.into(); + r.forwarder + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: getTrustedForwarderReturn = r.into(); + r.forwarder + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `isTrustedForwarder(address)` and selector `0x572b6c05`. +```solidity +function isTrustedForwarder(address forwarder) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isTrustedForwarderCall { + #[allow(missing_docs)] + pub forwarder: alloy::sol_types::private::Address, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`isTrustedForwarder(address)`](isTrustedForwarderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isTrustedForwarderReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isTrustedForwarderCall) -> Self { + (value.forwarder,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isTrustedForwarderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { forwarder: tuple.0 } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isTrustedForwarderReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isTrustedForwarderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isTrustedForwarderCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isTrustedForwarder(address)"; + const SELECTOR: [u8; 4] = [87u8, 43u8, 108u8, 5u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.forwarder, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isTrustedForwarderReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isTrustedForwarderReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`ERC2771Recipient`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum ERC2771RecipientCalls { + #[allow(missing_docs)] + getTrustedForwarder(getTrustedForwarderCall), + #[allow(missing_docs)] + isTrustedForwarder(isTrustedForwarderCall), + } + #[automatically_derived] + impl ERC2771RecipientCalls { + /// 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]] = &[ + [87u8, 43u8, 108u8, 5u8], + [206u8, 27u8, 129u8, 95u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for ERC2771RecipientCalls { + const NAME: &'static str = "ERC2771RecipientCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 2usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::getTrustedForwarder(_) => { + ::SELECTOR + } + Self::isTrustedForwarder(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn isTrustedForwarder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ERC2771RecipientCalls::isTrustedForwarder) + } + isTrustedForwarder + }, + { + fn getTrustedForwarder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ERC2771RecipientCalls::getTrustedForwarder) + } + getTrustedForwarder + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn isTrustedForwarder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ERC2771RecipientCalls::isTrustedForwarder) + } + isTrustedForwarder + }, + { + fn getTrustedForwarder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ERC2771RecipientCalls::getTrustedForwarder) + } + getTrustedForwarder + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::getTrustedForwarder(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::isTrustedForwarder(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::getTrustedForwarder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isTrustedForwarder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`ERC2771Recipient`](self) contract instance. + +See the [wrapper's documentation](`ERC2771RecipientInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> ERC2771RecipientInstance { + ERC2771RecipientInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + ERC2771RecipientInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + ERC2771RecipientInstance::::deploy_builder(provider) + } + /**A [`ERC2771Recipient`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`ERC2771Recipient`](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 ERC2771RecipientInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for ERC2771RecipientInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("ERC2771RecipientInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ERC2771RecipientInstance { + /**Creates a new wrapper around an on-chain [`ERC2771Recipient`](self) contract instance. + +See the [wrapper's documentation](`ERC2771RecipientInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 ERC2771RecipientInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> ERC2771RecipientInstance { + ERC2771RecipientInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ERC2771RecipientInstance { + /// 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( + &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 [`getTrustedForwarder`] function. + pub fn getTrustedForwarder( + &self, + ) -> alloy_contract::SolCallBuilder<&P, getTrustedForwarderCall, N> { + self.call_builder(&getTrustedForwarderCall) + } + ///Creates a new call builder for the [`isTrustedForwarder`] function. + pub fn isTrustedForwarder( + &self, + forwarder: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isTrustedForwarderCall, N> { + self.call_builder( + &isTrustedForwarderCall { + forwarder, + }, + ) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ERC2771RecipientInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/forked_strategy_template_tbtc.rs b/crates/bindings/src/forked_strategy_template_tbtc.rs new file mode 100644 index 000000000..f76f80720 --- /dev/null +++ b/crates/bindings/src/forked_strategy_template_tbtc.rs @@ -0,0 +1,7635 @@ +///Module containing a contract's types and functions. +/** + +```solidity +library StdInvariant { + struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } + struct FuzzInterface { address addr; string[] artifacts; } + struct FuzzSelector { address addr; bytes4[] selectors; } +} +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod StdInvariant { + use super::*; + use alloy::sol_types as alloy_sol_types; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzArtifactSelector { + #[allow(missing_docs)] + pub artifact: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub selectors: alloy::sol_types::private::Vec< + 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 as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::String, + alloy::sol_types::private::Vec>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzArtifactSelector) -> Self { + (value.artifact, value.selectors) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzArtifactSelector { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + artifact: tuple.0, + selectors: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzArtifactSelector { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.artifact, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.selectors), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzArtifactSelector { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzArtifactSelector { + const NAME: &'static str = "FuzzArtifactSelector"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzArtifactSelector(string artifact,bytes4[] selectors)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.artifact, + ) + .0, + , + > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzArtifactSelector { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.artifact, + ) + + , + > as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.selectors, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.artifact, + out, + ); + , + > as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.selectors, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzInterface { address addr; string[] artifacts; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzInterface { + #[allow(missing_docs)] + pub addr: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub artifacts: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzInterface) -> Self { + (value.addr, value.artifacts) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzInterface { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + addr: tuple.0, + artifacts: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzInterface { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzInterface { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.addr, + ), + as alloy_sol_types::SolType>::tokenize(&self.artifacts), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzInterface { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzInterface { + const NAME: &'static str = "FuzzInterface"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzInterface(address addr,string[] artifacts)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.addr, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzInterface { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.addr, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.artifacts, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.addr, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.artifacts, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzSelector { address addr; bytes4[] selectors; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzSelector { + #[allow(missing_docs)] + pub addr: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub selectors: alloy::sol_types::private::Vec< + 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 as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Vec>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzSelector) -> Self { + (value.addr, value.selectors) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzSelector { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + addr: tuple.0, + selectors: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzSelector { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzSelector { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.addr, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.selectors), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzSelector { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzSelector { + const NAME: &'static str = "FuzzSelector"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzSelector(address addr,bytes4[] selectors)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.addr, + ) + .0, + , + > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzSelector { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.addr, + ) + + , + > as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.selectors, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.addr, + out, + ); + , + > as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.selectors, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. + +See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> StdInvariantInstance { + StdInvariantInstance::::new(address, provider) + } + /**A [`StdInvariant`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`StdInvariant`](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 StdInvariantInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for StdInvariantInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("StdInvariantInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. + +See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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 StdInvariantInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> StdInvariantInstance { + StdInvariantInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} +/** + +Generated by the following Solidity interface... +```solidity +library StdInvariant { + struct FuzzArtifactSelector { + string artifact; + bytes4[] selectors; + } + struct FuzzInterface { + address addr; + string[] artifacts; + } + struct FuzzSelector { + address addr; + bytes4[] selectors; + } +} + +interface ForkedStrategyTemplateTbtc { + event log(string); + event log_address(address); + event log_array(uint256[] val); + event log_array(int256[] val); + event log_array(address[] val); + event log_bytes(bytes); + event log_bytes32(bytes32); + event log_int(int256); + event log_named_address(string key, address val); + event log_named_array(string key, uint256[] val); + event log_named_array(string key, int256[] val); + event log_named_array(string key, address[] val); + event log_named_bytes(string key, bytes val); + event log_named_bytes32(string key, bytes32 val); + event log_named_decimal_int(string key, int256 val, uint256 decimals); + event log_named_decimal_uint(string key, uint256 val, uint256 decimals); + event log_named_int(string key, int256 val); + event log_named_string(string key, string val); + event log_named_uint(string key, uint256 val); + event log_string(string); + event log_uint(uint256); + event logs(bytes); + + function IS_TEST() external view returns (bool); + function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); + function excludeContracts() external view returns (address[] memory excludedContracts_); + function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); + function excludeSenders() external view returns (address[] memory excludedSenders_); + function failed() external view returns (bool); + function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; + function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); + function targetArtifacts() external view returns (string[] memory targetedArtifacts_); + function targetContracts() external view returns (address[] memory targetedContracts_); + function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); + function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); + function targetSenders() external view returns (address[] memory targetedSenders_); + function token() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "IS_TEST", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeArtifacts", + "inputs": [], + "outputs": [ + { + "name": "excludedArtifacts_", + "type": "string[]", + "internalType": "string[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeContracts", + "inputs": [], + "outputs": [ + { + "name": "excludedContracts_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeSelectors", + "inputs": [], + "outputs": [ + { + "name": "excludedSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzSelector[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeSenders", + "inputs": [], + "outputs": [ + { + "name": "excludedSenders_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "failed", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "simulateForkAndTransfer", + "inputs": [ + { + "name": "forkAtBlock", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "sender", + "type": "address", + "internalType": "address" + }, + { + "name": "receiver", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "targetArtifactSelectors", + "inputs": [], + "outputs": [ + { + "name": "targetedArtifactSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzArtifactSelector[]", + "components": [ + { + "name": "artifact", + "type": "string", + "internalType": "string" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetArtifacts", + "inputs": [], + "outputs": [ + { + "name": "targetedArtifacts_", + "type": "string[]", + "internalType": "string[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetContracts", + "inputs": [], + "outputs": [ + { + "name": "targetedContracts_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetInterfaces", + "inputs": [], + "outputs": [ + { + "name": "targetedInterfaces_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzInterface[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "artifacts", + "type": "string[]", + "internalType": "string[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetSelectors", + "inputs": [], + "outputs": [ + { + "name": "targetedSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzSelector[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetSenders", + "inputs": [], + "outputs": [ + { + "name": "targetedSenders_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "token", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IERC20" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "log", + "inputs": [ + { + "name": "", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_address", + "inputs": [ + { + "name": "", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "uint256[]", + "indexed": false, + "internalType": "uint256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "int256[]", + "indexed": false, + "internalType": "int256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "address[]", + "indexed": false, + "internalType": "address[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_bytes", + "inputs": [ + { + "name": "", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_bytes32", + "inputs": [ + { + "name": "", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_int", + "inputs": [ + { + "name": "", + "type": "int256", + "indexed": false, + "internalType": "int256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_address", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256[]", + "indexed": false, + "internalType": "uint256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256[]", + "indexed": false, + "internalType": "int256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "address[]", + "indexed": false, + "internalType": "address[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_bytes", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_bytes32", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_decimal_int", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256", + "indexed": false, + "internalType": "int256" + }, + { + "name": "decimals", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_decimal_uint", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "decimals", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_int", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256", + "indexed": false, + "internalType": "int256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_string", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_uint", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_string", + "inputs": [ + { + "name": "", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_uint", + "inputs": [ + { + "name": "", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "logs", + "inputs": [ + { + "name": "", + "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 ForkedStrategyTemplateTbtc { + use super::*; + use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. +```solidity +event log(string); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log { + type DataTuple<'a> = (alloy::sol_types::sol_data::String,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log(string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, + 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, + 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. +```solidity +event log_address(address); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_address { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_address { + type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_address(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, + 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, + 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_address { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_address> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_address) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. +```solidity +event log_array(uint256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_0 { + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_0 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(uint256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, + 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, + 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_0 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_0> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. +```solidity +event log_array(int256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_1 { + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_1 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(int256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, + 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, + 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_1 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_1> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. +```solidity +event log_array(address[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_2 { + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_2 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(address[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, + 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, + 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_2 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_2> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. +```solidity +event log_bytes(bytes); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_bytes { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_bytes { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_bytes(bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, + 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, + 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_bytes { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_bytes> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. +```solidity +event log_bytes32(bytes32); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_bytes32 { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_bytes32 { + type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_bytes32(bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, + 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, + 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_bytes32 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_bytes32> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. +```solidity +event log_int(int256); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_int { + #[allow(missing_docs)] + pub _0: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_int { + type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_int(int256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, + 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, + 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. +```solidity +event log_named_address(string key, address val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_address { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_address { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Address, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_address(string,address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, + 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, + 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_address { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_address> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. +```solidity +event log_named_array(string key, uint256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_0 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_0 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, + 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, + 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_0 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_0> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. +```solidity +event log_named_array(string key, int256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_1 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_1 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,int256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, + 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, + 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_1 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_1> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. +```solidity +event log_named_array(string key, address[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_2 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_2 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,address[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, + 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, + 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_2 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_2> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. +```solidity +event log_named_bytes(string key, bytes val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_bytes { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_bytes { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Bytes, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, + 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, + 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_bytes { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_bytes> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. +```solidity +event log_named_bytes32(string key, bytes32 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_bytes32 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_bytes32 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::FixedBytes<32>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, + 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, + 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_bytes32 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. +```solidity +event log_named_decimal_int(string key, int256 val, uint256 decimals); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_decimal_int { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::I256, + #[allow(missing_docs)] + pub decimals: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_decimal_int { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Int<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, + 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, + 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + key: data.0, + val: data.1, + decimals: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + as alloy_sol_types::SolType>::tokenize(&self.decimals), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_decimal_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. +```solidity +event log_named_decimal_uint(string key, uint256 val, uint256 decimals); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_decimal_uint { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub decimals: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_decimal_uint { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, + 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, + 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + key: data.0, + val: data.1, + decimals: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + as alloy_sol_types::SolType>::tokenize(&self.decimals), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. +```solidity +event log_named_int(string key, int256 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_int { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_int { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Int<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_int(string,int256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, + 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, + 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. +```solidity +event log_named_string(string key, string val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_string { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::String, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_string { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::String, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_string(string,string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, + 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, + 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_string { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_string> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. +```solidity +event log_named_uint(string key, uint256 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_uint { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_uint { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, + 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, + 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. +```solidity +event log_string(string); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_string { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_string { + type DataTuple<'a> = (alloy::sol_types::sol_data::String,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_string(string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, + 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, + 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_string { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_string> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_string) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. +```solidity +event log_uint(uint256); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_uint { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_uint { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_uint(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, + 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, + 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. +```solidity +event logs(bytes); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct logs { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for logs { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "logs(bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, + 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, + 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 logs { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&logs> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &logs) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. +```solidity +function IS_TEST() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IS_TESTCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IS_TESTReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IS_TESTCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IS_TESTCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IS_TESTReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IS_TESTReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for IS_TESTCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "IS_TEST()"; + const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: IS_TESTReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: IS_TESTReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. +```solidity +function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeArtifactsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeArtifactsReturn { + #[allow(missing_docs)] + pub excludedArtifacts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeArtifactsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeArtifactsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeArtifactsReturn) -> Self { + (value.excludedArtifacts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeArtifactsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedArtifacts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeArtifactsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeArtifacts()"; + const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeArtifactsReturn = r.into(); + r.excludedArtifacts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeArtifactsReturn = r.into(); + r.excludedArtifacts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. +```solidity +function excludeContracts() external view returns (address[] memory excludedContracts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeContractsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeContractsReturn { + #[allow(missing_docs)] + pub excludedContracts_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeContractsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeContractsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeContractsReturn) -> Self { + (value.excludedContracts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeContractsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedContracts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeContractsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeContracts()"; + const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeContractsReturn = r.into(); + r.excludedContracts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeContractsReturn = r.into(); + r.excludedContracts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. +```solidity +function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSelectorsReturn { + #[allow(missing_docs)] + pub excludedSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSelectorsReturn) -> Self { + (value.excludedSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeSelectors()"; + const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeSelectorsReturn = r.into(); + r.excludedSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeSelectorsReturn = r.into(); + r.excludedSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. +```solidity +function excludeSenders() external view returns (address[] memory excludedSenders_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSendersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSendersReturn { + #[allow(missing_docs)] + pub excludedSenders_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: excludeSendersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for excludeSendersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSendersReturn) -> Self { + (value.excludedSenders_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSendersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { excludedSenders_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeSendersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeSenders()"; + const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeSendersReturn = r.into(); + r.excludedSenders_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeSendersReturn = r.into(); + r.excludedSenders_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `failed()` and selector `0xba414fa6`. +```solidity +function failed() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct failedCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`failed()`](failedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct failedReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: failedCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for failedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: failedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for failedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for failedCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "failed()"; + const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: failedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: failedReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. +```solidity +function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct simulateForkAndTransferCall { + #[allow(missing_docs)] + pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub sender: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct simulateForkAndTransferReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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::Uint<256>, + ); + #[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::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferCall) -> Self { + (value.forkAtBlock, value.sender, value.receiver, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for simulateForkAndTransferCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + forkAtBlock: tuple.0, + sender: tuple.1, + receiver: tuple.2, + amount: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for simulateForkAndTransferReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl simulateForkAndTransferReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for simulateForkAndTransferCall { + type Parameters<'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::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = simulateForkAndTransferReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; + const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), + ::tokenize( + &self.sender, + ), + ::tokenize( + &self.receiver, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + simulateForkAndTransferReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. +```solidity +function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactSelectorsReturn { + #[allow(missing_docs)] + pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactSelectorsReturn) -> Self { + (value.targetedArtifactSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedArtifactSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetArtifactSelectors()"; + const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetArtifacts()` and selector `0x85226c81`. +```solidity +function targetArtifacts() external view returns (string[] memory targetedArtifacts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactsReturn { + #[allow(missing_docs)] + pub targetedArtifacts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetArtifactsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsReturn) -> Self { + (value.targetedArtifacts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedArtifacts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetArtifactsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetArtifacts()"; + const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetContracts()` and selector `0x3f7286f4`. +```solidity +function targetContracts() external view returns (address[] memory targetedContracts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetContractsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetContractsReturn { + #[allow(missing_docs)] + pub targetedContracts_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetContractsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetContractsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetContractsReturn) -> Self { + (value.targetedContracts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetContractsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedContracts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetContractsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetContracts()"; + const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetContractsReturn = r.into(); + r.targetedContracts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetContractsReturn = r.into(); + r.targetedContracts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. +```solidity +function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetInterfacesCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetInterfacesReturn { + #[allow(missing_docs)] + pub targetedInterfaces_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetInterfacesCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetInterfacesCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetInterfacesReturn) -> Self { + (value.targetedInterfaces_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetInterfacesReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedInterfaces_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetInterfacesCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetInterfaces()"; + const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetSelectors()` and selector `0x916a17c6`. +```solidity +function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSelectorsReturn { + #[allow(missing_docs)] + pub targetedSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetSelectorsReturn) -> Self { + (value.targetedSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetSelectors()"; + const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. +```solidity +function targetSenders() external view returns (address[] memory targetedSenders_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSendersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSendersReturn { + #[allow(missing_docs)] + pub targetedSenders_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSendersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersReturn) -> Self { + (value.targetedSenders_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSendersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { targetedSenders_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetSendersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetSenders()"; + const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetSendersReturn = r.into(); + r.targetedSenders_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetSendersReturn = r.into(); + r.targetedSenders_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `token()` and selector `0xfc0c546a`. +```solidity +function token() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct tokenCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`token()`](tokenCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct tokenReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for tokenCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for tokenReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for tokenCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "token()"; + const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`ForkedStrategyTemplateTbtc`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum ForkedStrategyTemplateTbtcCalls { + #[allow(missing_docs)] + IS_TEST(IS_TESTCall), + #[allow(missing_docs)] + excludeArtifacts(excludeArtifactsCall), + #[allow(missing_docs)] + excludeContracts(excludeContractsCall), + #[allow(missing_docs)] + excludeSelectors(excludeSelectorsCall), + #[allow(missing_docs)] + excludeSenders(excludeSendersCall), + #[allow(missing_docs)] + failed(failedCall), + #[allow(missing_docs)] + simulateForkAndTransfer(simulateForkAndTransferCall), + #[allow(missing_docs)] + targetArtifactSelectors(targetArtifactSelectorsCall), + #[allow(missing_docs)] + targetArtifacts(targetArtifactsCall), + #[allow(missing_docs)] + targetContracts(targetContractsCall), + #[allow(missing_docs)] + targetInterfaces(targetInterfacesCall), + #[allow(missing_docs)] + targetSelectors(targetSelectorsCall), + #[allow(missing_docs)] + targetSenders(targetSendersCall), + #[allow(missing_docs)] + token(tokenCall), + } + #[automatically_derived] + impl ForkedStrategyTemplateTbtcCalls { + /// 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]] = &[ + [30u8, 215u8, 131u8, 28u8], + [42u8, 222u8, 56u8, 128u8], + [62u8, 94u8, 60u8, 35u8], + [63u8, 114u8, 134u8, 244u8], + [102u8, 217u8, 169u8, 160u8], + [133u8, 34u8, 108u8, 129u8], + [145u8, 106u8, 23u8, 198u8], + [176u8, 70u8, 79u8, 220u8], + [181u8, 80u8, 138u8, 169u8], + [186u8, 65u8, 79u8, 166u8], + [226u8, 12u8, 159u8, 113u8], + [249u8, 206u8, 14u8, 90u8], + [250u8, 118u8, 38u8, 212u8], + [252u8, 12u8, 84u8, 106u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for ForkedStrategyTemplateTbtcCalls { + const NAME: &'static str = "ForkedStrategyTemplateTbtcCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 14usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::IS_TEST(_) => ::SELECTOR, + Self::excludeArtifacts(_) => { + ::SELECTOR + } + Self::excludeContracts(_) => { + ::SELECTOR + } + Self::excludeSelectors(_) => { + ::SELECTOR + } + Self::excludeSenders(_) => { + ::SELECTOR + } + Self::failed(_) => ::SELECTOR, + Self::simulateForkAndTransfer(_) => { + ::SELECTOR + } + Self::targetArtifactSelectors(_) => { + ::SELECTOR + } + Self::targetArtifacts(_) => { + ::SELECTOR + } + Self::targetContracts(_) => { + ::SELECTOR + } + Self::targetInterfaces(_) => { + ::SELECTOR + } + Self::targetSelectors(_) => { + ::SELECTOR + } + Self::targetSenders(_) => { + ::SELECTOR + } + Self::token(_) => ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn excludeSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ForkedStrategyTemplateTbtcCalls::excludeSenders) + } + excludeSenders + }, + { + fn targetInterfaces( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ForkedStrategyTemplateTbtcCalls::targetInterfaces) + } + targetInterfaces + }, + { + fn targetSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ForkedStrategyTemplateTbtcCalls::targetSenders) + } + targetSenders + }, + { + fn targetContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ForkedStrategyTemplateTbtcCalls::targetContracts) + } + targetContracts + }, + { + fn targetArtifactSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + ForkedStrategyTemplateTbtcCalls::targetArtifactSelectors, + ) + } + targetArtifactSelectors + }, + { + fn targetArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ForkedStrategyTemplateTbtcCalls::targetArtifacts) + } + targetArtifacts + }, + { + fn targetSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ForkedStrategyTemplateTbtcCalls::targetSelectors) + } + targetSelectors + }, + { + fn excludeSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ForkedStrategyTemplateTbtcCalls::excludeSelectors) + } + excludeSelectors + }, + { + fn excludeArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ForkedStrategyTemplateTbtcCalls::excludeArtifacts) + } + excludeArtifacts + }, + { + fn failed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ForkedStrategyTemplateTbtcCalls::failed) + } + failed + }, + { + fn excludeContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ForkedStrategyTemplateTbtcCalls::excludeContracts) + } + excludeContracts + }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + ForkedStrategyTemplateTbtcCalls::simulateForkAndTransfer, + ) + } + simulateForkAndTransfer + }, + { + fn IS_TEST( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ForkedStrategyTemplateTbtcCalls::IS_TEST) + } + IS_TEST + }, + { + fn token( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ForkedStrategyTemplateTbtcCalls::token) + } + token + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn excludeSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateTbtcCalls::excludeSenders) + } + excludeSenders + }, + { + fn targetInterfaces( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateTbtcCalls::targetInterfaces) + } + targetInterfaces + }, + { + fn targetSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateTbtcCalls::targetSenders) + } + targetSenders + }, + { + fn targetContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateTbtcCalls::targetContracts) + } + targetContracts + }, + { + fn targetArtifactSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + ForkedStrategyTemplateTbtcCalls::targetArtifactSelectors, + ) + } + targetArtifactSelectors + }, + { + fn targetArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateTbtcCalls::targetArtifacts) + } + targetArtifacts + }, + { + fn targetSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateTbtcCalls::targetSelectors) + } + targetSelectors + }, + { + fn excludeSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateTbtcCalls::excludeSelectors) + } + excludeSelectors + }, + { + fn excludeArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateTbtcCalls::excludeArtifacts) + } + excludeArtifacts + }, + { + fn failed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateTbtcCalls::failed) + } + failed + }, + { + fn excludeContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateTbtcCalls::excludeContracts) + } + excludeContracts + }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + ForkedStrategyTemplateTbtcCalls::simulateForkAndTransfer, + ) + } + simulateForkAndTransfer + }, + { + fn IS_TEST( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateTbtcCalls::IS_TEST) + } + IS_TEST + }, + { + fn token( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateTbtcCalls::token) + } + token + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::IS_TEST(inner) => { + ::abi_encoded_size(inner) + } + Self::excludeArtifacts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeContracts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeSenders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::failed(inner) => { + ::abi_encoded_size(inner) + } + Self::simulateForkAndTransfer(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetArtifactSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetArtifacts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetContracts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetInterfaces(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetSenders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::token(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::IS_TEST(inner) => { + ::abi_encode_raw(inner, out) + } + Self::excludeArtifacts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeContracts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeSenders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::failed(inner) => { + ::abi_encode_raw(inner, out) + } + Self::simulateForkAndTransfer(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetArtifactSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetArtifacts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetContracts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetInterfaces(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetSenders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::token(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + ///Container for all the [`ForkedStrategyTemplateTbtc`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum ForkedStrategyTemplateTbtcEvents { + #[allow(missing_docs)] + log(log), + #[allow(missing_docs)] + log_address(log_address), + #[allow(missing_docs)] + log_array_0(log_array_0), + #[allow(missing_docs)] + log_array_1(log_array_1), + #[allow(missing_docs)] + log_array_2(log_array_2), + #[allow(missing_docs)] + log_bytes(log_bytes), + #[allow(missing_docs)] + log_bytes32(log_bytes32), + #[allow(missing_docs)] + log_int(log_int), + #[allow(missing_docs)] + log_named_address(log_named_address), + #[allow(missing_docs)] + log_named_array_0(log_named_array_0), + #[allow(missing_docs)] + log_named_array_1(log_named_array_1), + #[allow(missing_docs)] + log_named_array_2(log_named_array_2), + #[allow(missing_docs)] + log_named_bytes(log_named_bytes), + #[allow(missing_docs)] + log_named_bytes32(log_named_bytes32), + #[allow(missing_docs)] + log_named_decimal_int(log_named_decimal_int), + #[allow(missing_docs)] + log_named_decimal_uint(log_named_decimal_uint), + #[allow(missing_docs)] + log_named_int(log_named_int), + #[allow(missing_docs)] + log_named_string(log_named_string), + #[allow(missing_docs)] + log_named_uint(log_named_uint), + #[allow(missing_docs)] + log_string(log_string), + #[allow(missing_docs)] + log_uint(log_uint), + #[allow(missing_docs)] + logs(logs), + } + #[automatically_derived] + impl ForkedStrategyTemplateTbtcEvents { + /// 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]] = &[ + [ + 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, + 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, + 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, + ], + [ + 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, + 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, + 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, + ], + [ + 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, + 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, + 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, + ], + [ + 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, + 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, + 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, + ], + [ + 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, + 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, + 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, + ], + [ + 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, + 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, + 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, + ], + [ + 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, + 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, + 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, + ], + [ + 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, + 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, + 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, + ], + [ + 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, + 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, + 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, + ], + [ + 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, + 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, + 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, + ], + [ + 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, + 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, + 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, + ], + [ + 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, + 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, + 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, + ], + [ + 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, + 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, + 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, + ], + [ + 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, + 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, + 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, + ], + [ + 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, + 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, + 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, + ], + [ + 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, + 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, + 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, + ], + [ + 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, + 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, + 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, + ], + [ + 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, + 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, + 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, + ], + [ + 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, + 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, + 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, + ], + [ + 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, + 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, + 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, + ], + [ + 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, + 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, + 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, + ], + [ + 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, + 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, + 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for ForkedStrategyTemplateTbtcEvents { + const NAME: &'static str = "ForkedStrategyTemplateTbtcEvents"; + const COUNT: usize = 22usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_address) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_0) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_1) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_2) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_bytes) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_bytes32) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log_int) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_address) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_0) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_1) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_2) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_bytes) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_bytes32) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_decimal_int) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_decimal_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_int) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_string) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_string) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::logs) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 ForkedStrategyTemplateTbtcEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::log(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_address(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_0(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_1(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_2(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_bytes(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_address(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_0(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_1(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_2(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_bytes(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_decimal_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_decimal_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_string(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_string(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::logs(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::log(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_address(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_0(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_1(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_2(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_bytes(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_address(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_0(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_1(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_2(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_bytes(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_decimal_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_decimal_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_string(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_string(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::logs(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`ForkedStrategyTemplateTbtc`](self) contract instance. + +See the [wrapper's documentation](`ForkedStrategyTemplateTbtcInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> ForkedStrategyTemplateTbtcInstance { + ForkedStrategyTemplateTbtcInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + ForkedStrategyTemplateTbtcInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + ForkedStrategyTemplateTbtcInstance::::deploy_builder(provider) + } + /**A [`ForkedStrategyTemplateTbtc`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`ForkedStrategyTemplateTbtc`](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 ForkedStrategyTemplateTbtcInstance< + P, + N = alloy_contract::private::Ethereum, + > { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for ForkedStrategyTemplateTbtcInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("ForkedStrategyTemplateTbtcInstance") + .field(&self.address) + .finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ForkedStrategyTemplateTbtcInstance { + /**Creates a new wrapper around an on-chain [`ForkedStrategyTemplateTbtc`](self) contract instance. + +See the [wrapper's documentation](`ForkedStrategyTemplateTbtcInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 ForkedStrategyTemplateTbtcInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> ForkedStrategyTemplateTbtcInstance { + ForkedStrategyTemplateTbtcInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ForkedStrategyTemplateTbtcInstance { + /// 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( + &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 [`IS_TEST`] function. + pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { + self.call_builder(&IS_TESTCall) + } + ///Creates a new call builder for the [`excludeArtifacts`] function. + pub fn excludeArtifacts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { + self.call_builder(&excludeArtifactsCall) + } + ///Creates a new call builder for the [`excludeContracts`] function. + pub fn excludeContracts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { + self.call_builder(&excludeContractsCall) + } + ///Creates a new call builder for the [`excludeSelectors`] function. + pub fn excludeSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { + self.call_builder(&excludeSelectorsCall) + } + ///Creates a new call builder for the [`excludeSenders`] function. + pub fn excludeSenders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { + self.call_builder(&excludeSendersCall) + } + ///Creates a new call builder for the [`failed`] function. + pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { + self.call_builder(&failedCall) + } + ///Creates a new call builder for the [`simulateForkAndTransfer`] function. + pub fn simulateForkAndTransfer( + &self, + forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + sender: alloy::sol_types::private::Address, + receiver: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { + self.call_builder( + &simulateForkAndTransferCall { + forkAtBlock, + sender, + receiver, + amount, + }, + ) + } + ///Creates a new call builder for the [`targetArtifactSelectors`] function. + pub fn targetArtifactSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { + self.call_builder(&targetArtifactSelectorsCall) + } + ///Creates a new call builder for the [`targetArtifacts`] function. + pub fn targetArtifacts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { + self.call_builder(&targetArtifactsCall) + } + ///Creates a new call builder for the [`targetContracts`] function. + pub fn targetContracts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { + self.call_builder(&targetContractsCall) + } + ///Creates a new call builder for the [`targetInterfaces`] function. + pub fn targetInterfaces( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { + self.call_builder(&targetInterfacesCall) + } + ///Creates a new call builder for the [`targetSelectors`] function. + pub fn targetSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { + self.call_builder(&targetSelectorsCall) + } + ///Creates a new call builder for the [`targetSenders`] function. + pub fn targetSenders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { + self.call_builder(&targetSendersCall) + } + ///Creates a new call builder for the [`token`] function. + pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { + self.call_builder(&tokenCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ForkedStrategyTemplateTbtcInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`log`] event. + pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_address`] event. + pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_0`] event. + pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_1`] event. + pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_2`] event. + pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_bytes`] event. + pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_bytes32`] event. + pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_int`] event. + pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_address`] event. + pub fn log_named_address_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_address, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_0`] event. + pub fn log_named_array_0_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_0, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_1`] event. + pub fn log_named_array_1_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_1, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_2`] event. + pub fn log_named_array_2_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_2, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_bytes`] event. + pub fn log_named_bytes_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_bytes, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_bytes32`] event. + pub fn log_named_bytes32_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_bytes32, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_decimal_int`] event. + pub fn log_named_decimal_int_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_decimal_uint`] event. + pub fn log_named_decimal_uint_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_int`] event. + pub fn log_named_int_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_string`] event. + pub fn log_named_string_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_string, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_uint`] event. + pub fn log_named_uint_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_string`] event. + pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_uint`] event. + pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`logs`] event. + pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/forked_strategy_template_wbtc.rs b/crates/bindings/src/forked_strategy_template_wbtc.rs new file mode 100644 index 000000000..160f764d9 --- /dev/null +++ b/crates/bindings/src/forked_strategy_template_wbtc.rs @@ -0,0 +1,7635 @@ +///Module containing a contract's types and functions. +/** + +```solidity +library StdInvariant { + struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } + struct FuzzInterface { address addr; string[] artifacts; } + struct FuzzSelector { address addr; bytes4[] selectors; } +} +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod StdInvariant { + use super::*; + use alloy::sol_types as alloy_sol_types; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzArtifactSelector { + #[allow(missing_docs)] + pub artifact: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub selectors: alloy::sol_types::private::Vec< + 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 as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::String, + alloy::sol_types::private::Vec>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzArtifactSelector) -> Self { + (value.artifact, value.selectors) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzArtifactSelector { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + artifact: tuple.0, + selectors: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzArtifactSelector { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.artifact, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.selectors), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzArtifactSelector { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzArtifactSelector { + const NAME: &'static str = "FuzzArtifactSelector"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzArtifactSelector(string artifact,bytes4[] selectors)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.artifact, + ) + .0, + , + > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzArtifactSelector { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.artifact, + ) + + , + > as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.selectors, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.artifact, + out, + ); + , + > as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.selectors, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzInterface { address addr; string[] artifacts; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzInterface { + #[allow(missing_docs)] + pub addr: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub artifacts: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzInterface) -> Self { + (value.addr, value.artifacts) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzInterface { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + addr: tuple.0, + artifacts: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzInterface { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzInterface { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.addr, + ), + as alloy_sol_types::SolType>::tokenize(&self.artifacts), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzInterface { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzInterface { + const NAME: &'static str = "FuzzInterface"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzInterface(address addr,string[] artifacts)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.addr, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzInterface { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.addr, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.artifacts, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.addr, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.artifacts, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzSelector { address addr; bytes4[] selectors; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzSelector { + #[allow(missing_docs)] + pub addr: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub selectors: alloy::sol_types::private::Vec< + 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 as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Vec>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzSelector) -> Self { + (value.addr, value.selectors) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzSelector { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + addr: tuple.0, + selectors: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzSelector { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzSelector { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.addr, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.selectors), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzSelector { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzSelector { + const NAME: &'static str = "FuzzSelector"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzSelector(address addr,bytes4[] selectors)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.addr, + ) + .0, + , + > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzSelector { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.addr, + ) + + , + > as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.selectors, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.addr, + out, + ); + , + > as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.selectors, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. + +See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> StdInvariantInstance { + StdInvariantInstance::::new(address, provider) + } + /**A [`StdInvariant`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`StdInvariant`](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 StdInvariantInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for StdInvariantInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("StdInvariantInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. + +See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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 StdInvariantInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> StdInvariantInstance { + StdInvariantInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} +/** + +Generated by the following Solidity interface... +```solidity +library StdInvariant { + struct FuzzArtifactSelector { + string artifact; + bytes4[] selectors; + } + struct FuzzInterface { + address addr; + string[] artifacts; + } + struct FuzzSelector { + address addr; + bytes4[] selectors; + } +} + +interface ForkedStrategyTemplateWbtc { + event log(string); + event log_address(address); + event log_array(uint256[] val); + event log_array(int256[] val); + event log_array(address[] val); + event log_bytes(bytes); + event log_bytes32(bytes32); + event log_int(int256); + event log_named_address(string key, address val); + event log_named_array(string key, uint256[] val); + event log_named_array(string key, int256[] val); + event log_named_array(string key, address[] val); + event log_named_bytes(string key, bytes val); + event log_named_bytes32(string key, bytes32 val); + event log_named_decimal_int(string key, int256 val, uint256 decimals); + event log_named_decimal_uint(string key, uint256 val, uint256 decimals); + event log_named_int(string key, int256 val); + event log_named_string(string key, string val); + event log_named_uint(string key, uint256 val); + event log_string(string); + event log_uint(uint256); + event logs(bytes); + + function IS_TEST() external view returns (bool); + function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); + function excludeContracts() external view returns (address[] memory excludedContracts_); + function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); + function excludeSenders() external view returns (address[] memory excludedSenders_); + function failed() external view returns (bool); + function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; + function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); + function targetArtifacts() external view returns (string[] memory targetedArtifacts_); + function targetContracts() external view returns (address[] memory targetedContracts_); + function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); + function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); + function targetSenders() external view returns (address[] memory targetedSenders_); + function token() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "IS_TEST", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeArtifacts", + "inputs": [], + "outputs": [ + { + "name": "excludedArtifacts_", + "type": "string[]", + "internalType": "string[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeContracts", + "inputs": [], + "outputs": [ + { + "name": "excludedContracts_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeSelectors", + "inputs": [], + "outputs": [ + { + "name": "excludedSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzSelector[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeSenders", + "inputs": [], + "outputs": [ + { + "name": "excludedSenders_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "failed", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "simulateForkAndTransfer", + "inputs": [ + { + "name": "forkAtBlock", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "sender", + "type": "address", + "internalType": "address" + }, + { + "name": "receiver", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "targetArtifactSelectors", + "inputs": [], + "outputs": [ + { + "name": "targetedArtifactSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzArtifactSelector[]", + "components": [ + { + "name": "artifact", + "type": "string", + "internalType": "string" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetArtifacts", + "inputs": [], + "outputs": [ + { + "name": "targetedArtifacts_", + "type": "string[]", + "internalType": "string[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetContracts", + "inputs": [], + "outputs": [ + { + "name": "targetedContracts_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetInterfaces", + "inputs": [], + "outputs": [ + { + "name": "targetedInterfaces_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzInterface[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "artifacts", + "type": "string[]", + "internalType": "string[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetSelectors", + "inputs": [], + "outputs": [ + { + "name": "targetedSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzSelector[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetSenders", + "inputs": [], + "outputs": [ + { + "name": "targetedSenders_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "token", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IERC20" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "log", + "inputs": [ + { + "name": "", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_address", + "inputs": [ + { + "name": "", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "uint256[]", + "indexed": false, + "internalType": "uint256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "int256[]", + "indexed": false, + "internalType": "int256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "address[]", + "indexed": false, + "internalType": "address[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_bytes", + "inputs": [ + { + "name": "", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_bytes32", + "inputs": [ + { + "name": "", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_int", + "inputs": [ + { + "name": "", + "type": "int256", + "indexed": false, + "internalType": "int256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_address", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256[]", + "indexed": false, + "internalType": "uint256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256[]", + "indexed": false, + "internalType": "int256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "address[]", + "indexed": false, + "internalType": "address[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_bytes", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_bytes32", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_decimal_int", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256", + "indexed": false, + "internalType": "int256" + }, + { + "name": "decimals", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_decimal_uint", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "decimals", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_int", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256", + "indexed": false, + "internalType": "int256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_string", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_uint", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_string", + "inputs": [ + { + "name": "", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_uint", + "inputs": [ + { + "name": "", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "logs", + "inputs": [ + { + "name": "", + "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 ForkedStrategyTemplateWbtc { + use super::*; + use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. +```solidity +event log(string); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log { + type DataTuple<'a> = (alloy::sol_types::sol_data::String,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log(string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, + 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, + 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. +```solidity +event log_address(address); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_address { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_address { + type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_address(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, + 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, + 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_address { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_address> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_address) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. +```solidity +event log_array(uint256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_0 { + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_0 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(uint256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, + 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, + 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_0 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_0> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. +```solidity +event log_array(int256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_1 { + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_1 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(int256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, + 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, + 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_1 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_1> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. +```solidity +event log_array(address[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_2 { + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_2 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(address[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, + 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, + 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_2 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_2> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. +```solidity +event log_bytes(bytes); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_bytes { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_bytes { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_bytes(bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, + 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, + 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_bytes { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_bytes> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. +```solidity +event log_bytes32(bytes32); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_bytes32 { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_bytes32 { + type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_bytes32(bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, + 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, + 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_bytes32 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_bytes32> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. +```solidity +event log_int(int256); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_int { + #[allow(missing_docs)] + pub _0: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_int { + type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_int(int256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, + 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, + 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. +```solidity +event log_named_address(string key, address val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_address { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_address { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Address, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_address(string,address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, + 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, + 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_address { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_address> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. +```solidity +event log_named_array(string key, uint256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_0 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_0 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, + 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, + 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_0 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_0> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. +```solidity +event log_named_array(string key, int256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_1 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_1 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,int256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, + 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, + 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_1 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_1> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. +```solidity +event log_named_array(string key, address[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_2 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_2 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,address[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, + 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, + 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_2 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_2> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. +```solidity +event log_named_bytes(string key, bytes val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_bytes { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_bytes { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Bytes, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, + 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, + 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_bytes { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_bytes> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. +```solidity +event log_named_bytes32(string key, bytes32 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_bytes32 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_bytes32 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::FixedBytes<32>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, + 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, + 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_bytes32 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. +```solidity +event log_named_decimal_int(string key, int256 val, uint256 decimals); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_decimal_int { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::I256, + #[allow(missing_docs)] + pub decimals: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_decimal_int { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Int<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, + 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, + 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + key: data.0, + val: data.1, + decimals: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + as alloy_sol_types::SolType>::tokenize(&self.decimals), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_decimal_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. +```solidity +event log_named_decimal_uint(string key, uint256 val, uint256 decimals); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_decimal_uint { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub decimals: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_decimal_uint { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, + 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, + 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + key: data.0, + val: data.1, + decimals: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + as alloy_sol_types::SolType>::tokenize(&self.decimals), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. +```solidity +event log_named_int(string key, int256 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_int { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_int { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Int<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_int(string,int256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, + 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, + 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. +```solidity +event log_named_string(string key, string val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_string { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::String, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_string { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::String, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_string(string,string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, + 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, + 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_string { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_string> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. +```solidity +event log_named_uint(string key, uint256 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_uint { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_uint { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, + 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, + 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. +```solidity +event log_string(string); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_string { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_string { + type DataTuple<'a> = (alloy::sol_types::sol_data::String,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_string(string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, + 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, + 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_string { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_string> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_string) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. +```solidity +event log_uint(uint256); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_uint { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_uint { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_uint(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, + 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, + 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. +```solidity +event logs(bytes); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct logs { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for logs { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "logs(bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, + 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, + 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 logs { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&logs> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &logs) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. +```solidity +function IS_TEST() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IS_TESTCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IS_TESTReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IS_TESTCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IS_TESTCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IS_TESTReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IS_TESTReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for IS_TESTCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "IS_TEST()"; + const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: IS_TESTReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: IS_TESTReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. +```solidity +function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeArtifactsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeArtifactsReturn { + #[allow(missing_docs)] + pub excludedArtifacts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeArtifactsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeArtifactsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeArtifactsReturn) -> Self { + (value.excludedArtifacts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeArtifactsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedArtifacts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeArtifactsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeArtifacts()"; + const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeArtifactsReturn = r.into(); + r.excludedArtifacts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeArtifactsReturn = r.into(); + r.excludedArtifacts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. +```solidity +function excludeContracts() external view returns (address[] memory excludedContracts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeContractsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeContractsReturn { + #[allow(missing_docs)] + pub excludedContracts_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeContractsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeContractsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeContractsReturn) -> Self { + (value.excludedContracts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeContractsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedContracts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeContractsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeContracts()"; + const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeContractsReturn = r.into(); + r.excludedContracts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeContractsReturn = r.into(); + r.excludedContracts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. +```solidity +function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSelectorsReturn { + #[allow(missing_docs)] + pub excludedSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSelectorsReturn) -> Self { + (value.excludedSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeSelectors()"; + const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeSelectorsReturn = r.into(); + r.excludedSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeSelectorsReturn = r.into(); + r.excludedSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. +```solidity +function excludeSenders() external view returns (address[] memory excludedSenders_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSendersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSendersReturn { + #[allow(missing_docs)] + pub excludedSenders_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: excludeSendersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for excludeSendersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSendersReturn) -> Self { + (value.excludedSenders_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSendersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { excludedSenders_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeSendersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeSenders()"; + const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeSendersReturn = r.into(); + r.excludedSenders_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeSendersReturn = r.into(); + r.excludedSenders_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `failed()` and selector `0xba414fa6`. +```solidity +function failed() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct failedCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`failed()`](failedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct failedReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: failedCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for failedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: failedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for failedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for failedCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "failed()"; + const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: failedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: failedReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. +```solidity +function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct simulateForkAndTransferCall { + #[allow(missing_docs)] + pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub sender: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct simulateForkAndTransferReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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::Uint<256>, + ); + #[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::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferCall) -> Self { + (value.forkAtBlock, value.sender, value.receiver, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for simulateForkAndTransferCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + forkAtBlock: tuple.0, + sender: tuple.1, + receiver: tuple.2, + amount: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for simulateForkAndTransferReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl simulateForkAndTransferReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for simulateForkAndTransferCall { + type Parameters<'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::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = simulateForkAndTransferReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; + const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), + ::tokenize( + &self.sender, + ), + ::tokenize( + &self.receiver, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + simulateForkAndTransferReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. +```solidity +function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactSelectorsReturn { + #[allow(missing_docs)] + pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactSelectorsReturn) -> Self { + (value.targetedArtifactSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedArtifactSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetArtifactSelectors()"; + const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetArtifacts()` and selector `0x85226c81`. +```solidity +function targetArtifacts() external view returns (string[] memory targetedArtifacts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactsReturn { + #[allow(missing_docs)] + pub targetedArtifacts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetArtifactsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsReturn) -> Self { + (value.targetedArtifacts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedArtifacts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetArtifactsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetArtifacts()"; + const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetContracts()` and selector `0x3f7286f4`. +```solidity +function targetContracts() external view returns (address[] memory targetedContracts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetContractsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetContractsReturn { + #[allow(missing_docs)] + pub targetedContracts_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetContractsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetContractsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetContractsReturn) -> Self { + (value.targetedContracts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetContractsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedContracts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetContractsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetContracts()"; + const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetContractsReturn = r.into(); + r.targetedContracts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetContractsReturn = r.into(); + r.targetedContracts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. +```solidity +function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetInterfacesCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetInterfacesReturn { + #[allow(missing_docs)] + pub targetedInterfaces_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetInterfacesCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetInterfacesCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetInterfacesReturn) -> Self { + (value.targetedInterfaces_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetInterfacesReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedInterfaces_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetInterfacesCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetInterfaces()"; + const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetSelectors()` and selector `0x916a17c6`. +```solidity +function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSelectorsReturn { + #[allow(missing_docs)] + pub targetedSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetSelectorsReturn) -> Self { + (value.targetedSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetSelectors()"; + const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. +```solidity +function targetSenders() external view returns (address[] memory targetedSenders_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSendersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSendersReturn { + #[allow(missing_docs)] + pub targetedSenders_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSendersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersReturn) -> Self { + (value.targetedSenders_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSendersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { targetedSenders_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetSendersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetSenders()"; + const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetSendersReturn = r.into(); + r.targetedSenders_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetSendersReturn = r.into(); + r.targetedSenders_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `token()` and selector `0xfc0c546a`. +```solidity +function token() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct tokenCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`token()`](tokenCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct tokenReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for tokenCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for tokenReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for tokenCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "token()"; + const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`ForkedStrategyTemplateWbtc`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum ForkedStrategyTemplateWbtcCalls { + #[allow(missing_docs)] + IS_TEST(IS_TESTCall), + #[allow(missing_docs)] + excludeArtifacts(excludeArtifactsCall), + #[allow(missing_docs)] + excludeContracts(excludeContractsCall), + #[allow(missing_docs)] + excludeSelectors(excludeSelectorsCall), + #[allow(missing_docs)] + excludeSenders(excludeSendersCall), + #[allow(missing_docs)] + failed(failedCall), + #[allow(missing_docs)] + simulateForkAndTransfer(simulateForkAndTransferCall), + #[allow(missing_docs)] + targetArtifactSelectors(targetArtifactSelectorsCall), + #[allow(missing_docs)] + targetArtifacts(targetArtifactsCall), + #[allow(missing_docs)] + targetContracts(targetContractsCall), + #[allow(missing_docs)] + targetInterfaces(targetInterfacesCall), + #[allow(missing_docs)] + targetSelectors(targetSelectorsCall), + #[allow(missing_docs)] + targetSenders(targetSendersCall), + #[allow(missing_docs)] + token(tokenCall), + } + #[automatically_derived] + impl ForkedStrategyTemplateWbtcCalls { + /// 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]] = &[ + [30u8, 215u8, 131u8, 28u8], + [42u8, 222u8, 56u8, 128u8], + [62u8, 94u8, 60u8, 35u8], + [63u8, 114u8, 134u8, 244u8], + [102u8, 217u8, 169u8, 160u8], + [133u8, 34u8, 108u8, 129u8], + [145u8, 106u8, 23u8, 198u8], + [176u8, 70u8, 79u8, 220u8], + [181u8, 80u8, 138u8, 169u8], + [186u8, 65u8, 79u8, 166u8], + [226u8, 12u8, 159u8, 113u8], + [249u8, 206u8, 14u8, 90u8], + [250u8, 118u8, 38u8, 212u8], + [252u8, 12u8, 84u8, 106u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for ForkedStrategyTemplateWbtcCalls { + const NAME: &'static str = "ForkedStrategyTemplateWbtcCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 14usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::IS_TEST(_) => ::SELECTOR, + Self::excludeArtifacts(_) => { + ::SELECTOR + } + Self::excludeContracts(_) => { + ::SELECTOR + } + Self::excludeSelectors(_) => { + ::SELECTOR + } + Self::excludeSenders(_) => { + ::SELECTOR + } + Self::failed(_) => ::SELECTOR, + Self::simulateForkAndTransfer(_) => { + ::SELECTOR + } + Self::targetArtifactSelectors(_) => { + ::SELECTOR + } + Self::targetArtifacts(_) => { + ::SELECTOR + } + Self::targetContracts(_) => { + ::SELECTOR + } + Self::targetInterfaces(_) => { + ::SELECTOR + } + Self::targetSelectors(_) => { + ::SELECTOR + } + Self::targetSenders(_) => { + ::SELECTOR + } + Self::token(_) => ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn excludeSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ForkedStrategyTemplateWbtcCalls::excludeSenders) + } + excludeSenders + }, + { + fn targetInterfaces( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ForkedStrategyTemplateWbtcCalls::targetInterfaces) + } + targetInterfaces + }, + { + fn targetSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ForkedStrategyTemplateWbtcCalls::targetSenders) + } + targetSenders + }, + { + fn targetContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ForkedStrategyTemplateWbtcCalls::targetContracts) + } + targetContracts + }, + { + fn targetArtifactSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + ForkedStrategyTemplateWbtcCalls::targetArtifactSelectors, + ) + } + targetArtifactSelectors + }, + { + fn targetArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ForkedStrategyTemplateWbtcCalls::targetArtifacts) + } + targetArtifacts + }, + { + fn targetSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ForkedStrategyTemplateWbtcCalls::targetSelectors) + } + targetSelectors + }, + { + fn excludeSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ForkedStrategyTemplateWbtcCalls::excludeSelectors) + } + excludeSelectors + }, + { + fn excludeArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ForkedStrategyTemplateWbtcCalls::excludeArtifacts) + } + excludeArtifacts + }, + { + fn failed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ForkedStrategyTemplateWbtcCalls::failed) + } + failed + }, + { + fn excludeContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ForkedStrategyTemplateWbtcCalls::excludeContracts) + } + excludeContracts + }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + ForkedStrategyTemplateWbtcCalls::simulateForkAndTransfer, + ) + } + simulateForkAndTransfer + }, + { + fn IS_TEST( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ForkedStrategyTemplateWbtcCalls::IS_TEST) + } + IS_TEST + }, + { + fn token( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ForkedStrategyTemplateWbtcCalls::token) + } + token + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn excludeSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateWbtcCalls::excludeSenders) + } + excludeSenders + }, + { + fn targetInterfaces( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateWbtcCalls::targetInterfaces) + } + targetInterfaces + }, + { + fn targetSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateWbtcCalls::targetSenders) + } + targetSenders + }, + { + fn targetContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateWbtcCalls::targetContracts) + } + targetContracts + }, + { + fn targetArtifactSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + ForkedStrategyTemplateWbtcCalls::targetArtifactSelectors, + ) + } + targetArtifactSelectors + }, + { + fn targetArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateWbtcCalls::targetArtifacts) + } + targetArtifacts + }, + { + fn targetSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateWbtcCalls::targetSelectors) + } + targetSelectors + }, + { + fn excludeSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateWbtcCalls::excludeSelectors) + } + excludeSelectors + }, + { + fn excludeArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateWbtcCalls::excludeArtifacts) + } + excludeArtifacts + }, + { + fn failed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateWbtcCalls::failed) + } + failed + }, + { + fn excludeContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateWbtcCalls::excludeContracts) + } + excludeContracts + }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + ForkedStrategyTemplateWbtcCalls::simulateForkAndTransfer, + ) + } + simulateForkAndTransfer + }, + { + fn IS_TEST( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateWbtcCalls::IS_TEST) + } + IS_TEST + }, + { + fn token( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ForkedStrategyTemplateWbtcCalls::token) + } + token + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::IS_TEST(inner) => { + ::abi_encoded_size(inner) + } + Self::excludeArtifacts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeContracts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeSenders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::failed(inner) => { + ::abi_encoded_size(inner) + } + Self::simulateForkAndTransfer(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetArtifactSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetArtifacts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetContracts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetInterfaces(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetSenders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::token(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::IS_TEST(inner) => { + ::abi_encode_raw(inner, out) + } + Self::excludeArtifacts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeContracts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeSenders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::failed(inner) => { + ::abi_encode_raw(inner, out) + } + Self::simulateForkAndTransfer(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetArtifactSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetArtifacts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetContracts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetInterfaces(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetSenders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::token(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + ///Container for all the [`ForkedStrategyTemplateWbtc`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum ForkedStrategyTemplateWbtcEvents { + #[allow(missing_docs)] + log(log), + #[allow(missing_docs)] + log_address(log_address), + #[allow(missing_docs)] + log_array_0(log_array_0), + #[allow(missing_docs)] + log_array_1(log_array_1), + #[allow(missing_docs)] + log_array_2(log_array_2), + #[allow(missing_docs)] + log_bytes(log_bytes), + #[allow(missing_docs)] + log_bytes32(log_bytes32), + #[allow(missing_docs)] + log_int(log_int), + #[allow(missing_docs)] + log_named_address(log_named_address), + #[allow(missing_docs)] + log_named_array_0(log_named_array_0), + #[allow(missing_docs)] + log_named_array_1(log_named_array_1), + #[allow(missing_docs)] + log_named_array_2(log_named_array_2), + #[allow(missing_docs)] + log_named_bytes(log_named_bytes), + #[allow(missing_docs)] + log_named_bytes32(log_named_bytes32), + #[allow(missing_docs)] + log_named_decimal_int(log_named_decimal_int), + #[allow(missing_docs)] + log_named_decimal_uint(log_named_decimal_uint), + #[allow(missing_docs)] + log_named_int(log_named_int), + #[allow(missing_docs)] + log_named_string(log_named_string), + #[allow(missing_docs)] + log_named_uint(log_named_uint), + #[allow(missing_docs)] + log_string(log_string), + #[allow(missing_docs)] + log_uint(log_uint), + #[allow(missing_docs)] + logs(logs), + } + #[automatically_derived] + impl ForkedStrategyTemplateWbtcEvents { + /// 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]] = &[ + [ + 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, + 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, + 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, + ], + [ + 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, + 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, + 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, + ], + [ + 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, + 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, + 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, + ], + [ + 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, + 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, + 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, + ], + [ + 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, + 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, + 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, + ], + [ + 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, + 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, + 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, + ], + [ + 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, + 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, + 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, + ], + [ + 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, + 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, + 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, + ], + [ + 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, + 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, + 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, + ], + [ + 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, + 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, + 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, + ], + [ + 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, + 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, + 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, + ], + [ + 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, + 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, + 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, + ], + [ + 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, + 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, + 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, + ], + [ + 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, + 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, + 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, + ], + [ + 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, + 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, + 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, + ], + [ + 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, + 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, + 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, + ], + [ + 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, + 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, + 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, + ], + [ + 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, + 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, + 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, + ], + [ + 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, + 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, + 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, + ], + [ + 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, + 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, + 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, + ], + [ + 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, + 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, + 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, + ], + [ + 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, + 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, + 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for ForkedStrategyTemplateWbtcEvents { + const NAME: &'static str = "ForkedStrategyTemplateWbtcEvents"; + const COUNT: usize = 22usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_address) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_0) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_1) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_2) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_bytes) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_bytes32) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log_int) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_address) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_0) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_1) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_2) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_bytes) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_bytes32) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_decimal_int) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_decimal_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_int) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_string) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_string) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::logs) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 ForkedStrategyTemplateWbtcEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::log(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_address(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_0(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_1(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_2(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_bytes(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_address(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_0(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_1(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_2(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_bytes(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_decimal_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_decimal_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_string(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_string(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::logs(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::log(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_address(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_0(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_1(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_2(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_bytes(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_address(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_0(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_1(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_2(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_bytes(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_decimal_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_decimal_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_string(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_string(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::logs(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`ForkedStrategyTemplateWbtc`](self) contract instance. + +See the [wrapper's documentation](`ForkedStrategyTemplateWbtcInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> ForkedStrategyTemplateWbtcInstance { + ForkedStrategyTemplateWbtcInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + ForkedStrategyTemplateWbtcInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + ForkedStrategyTemplateWbtcInstance::::deploy_builder(provider) + } + /**A [`ForkedStrategyTemplateWbtc`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`ForkedStrategyTemplateWbtc`](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 ForkedStrategyTemplateWbtcInstance< + P, + N = alloy_contract::private::Ethereum, + > { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for ForkedStrategyTemplateWbtcInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("ForkedStrategyTemplateWbtcInstance") + .field(&self.address) + .finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ForkedStrategyTemplateWbtcInstance { + /**Creates a new wrapper around an on-chain [`ForkedStrategyTemplateWbtc`](self) contract instance. + +See the [wrapper's documentation](`ForkedStrategyTemplateWbtcInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 ForkedStrategyTemplateWbtcInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> ForkedStrategyTemplateWbtcInstance { + ForkedStrategyTemplateWbtcInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ForkedStrategyTemplateWbtcInstance { + /// 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( + &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 [`IS_TEST`] function. + pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { + self.call_builder(&IS_TESTCall) + } + ///Creates a new call builder for the [`excludeArtifacts`] function. + pub fn excludeArtifacts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { + self.call_builder(&excludeArtifactsCall) + } + ///Creates a new call builder for the [`excludeContracts`] function. + pub fn excludeContracts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { + self.call_builder(&excludeContractsCall) + } + ///Creates a new call builder for the [`excludeSelectors`] function. + pub fn excludeSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { + self.call_builder(&excludeSelectorsCall) + } + ///Creates a new call builder for the [`excludeSenders`] function. + pub fn excludeSenders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { + self.call_builder(&excludeSendersCall) + } + ///Creates a new call builder for the [`failed`] function. + pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { + self.call_builder(&failedCall) + } + ///Creates a new call builder for the [`simulateForkAndTransfer`] function. + pub fn simulateForkAndTransfer( + &self, + forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + sender: alloy::sol_types::private::Address, + receiver: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { + self.call_builder( + &simulateForkAndTransferCall { + forkAtBlock, + sender, + receiver, + amount, + }, + ) + } + ///Creates a new call builder for the [`targetArtifactSelectors`] function. + pub fn targetArtifactSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { + self.call_builder(&targetArtifactSelectorsCall) + } + ///Creates a new call builder for the [`targetArtifacts`] function. + pub fn targetArtifacts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { + self.call_builder(&targetArtifactsCall) + } + ///Creates a new call builder for the [`targetContracts`] function. + pub fn targetContracts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { + self.call_builder(&targetContractsCall) + } + ///Creates a new call builder for the [`targetInterfaces`] function. + pub fn targetInterfaces( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { + self.call_builder(&targetInterfacesCall) + } + ///Creates a new call builder for the [`targetSelectors`] function. + pub fn targetSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { + self.call_builder(&targetSelectorsCall) + } + ///Creates a new call builder for the [`targetSenders`] function. + pub fn targetSenders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { + self.call_builder(&targetSendersCall) + } + ///Creates a new call builder for the [`token`] function. + pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { + self.call_builder(&tokenCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ForkedStrategyTemplateWbtcInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`log`] event. + pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_address`] event. + pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_0`] event. + pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_1`] event. + pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_2`] event. + pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_bytes`] event. + pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_bytes32`] event. + pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_int`] event. + pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_address`] event. + pub fn log_named_address_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_address, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_0`] event. + pub fn log_named_array_0_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_0, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_1`] event. + pub fn log_named_array_1_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_1, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_2`] event. + pub fn log_named_array_2_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_2, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_bytes`] event. + pub fn log_named_bytes_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_bytes, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_bytes32`] event. + pub fn log_named_bytes32_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_bytes32, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_decimal_int`] event. + pub fn log_named_decimal_int_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_decimal_uint`] event. + pub fn log_named_decimal_uint_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_int`] event. + pub fn log_named_int_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_string`] event. + pub fn log_named_string_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_string, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_uint`] event. + pub fn log_named_uint_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_string`] event. + pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_uint`] event. + pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`logs`] event. + pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/fullrelay.rs b/crates/bindings/src/full_relay.rs similarity index 81% rename from crates/bindings/src/fullrelay.rs rename to crates/bindings/src/full_relay.rs index ab4ba27e0..974f312db 100644 --- a/crates/bindings/src/fullrelay.rs +++ b/crates/bindings/src/full_relay.rs @@ -343,22 +343,22 @@ pub mod FullRelay { /// 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\x15a\0\x0FW__\xFD[P`@Qa!\xB48\x03\x80a!\xB4\x839\x81\x01`@\x81\x90Ra\0.\x91a\x03\x19V[\x82Q`P\x14a\0xW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x11`$\x82\x01RpBad genesis block`x\x1B`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\0\x82\x84a\x01TV[\x90Pb\xFF\xFF\xFF\x82\x16\x15a\0\xFDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FPeriod start hash does not have `D\x82\x01R\x7Fwork. Hint: wrong byte order?\0\0\0`d\x82\x01R`\x84\x01a\0oV[_\x81\x81U`\x01\x82\x90U`\x02\x82\x90U\x81\x81R`\x04` R`@\x90 \x83\x90Ua\x01&a\x07\xE0\x84a\x03\xECV[a\x010\x90\x84a\x04\x13V[_\x83\x81R`\x04` R`@\x90 Ua\x01G\x84a\x02\x14V[`\x05UPa\x05\xAB\x92PPPV[_`\x02\x80\x83`@Qa\x01f\x91\x90a\x04&V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\x81W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xA4\x91\x90a\x04=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\x0E\x91\x90a\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[\x86a\x0BI\x8B\x83a\x13'V[\x14a\x0B\xBCW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x02sV[\x82\x96P`P\x81a\x0B\xCC\x91\x90a\x19\xD5V[\x90Pa\x08\xDAV[P\x81a\x0B\xDE\x8Ba\x11\x86V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x0C\x8FW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02sV[_a\x0C\x99\x84a\x11\x86V[\x90P_a\x0C\xA5\x86a\x11\x86V[\x90P`\x01T\x81\x14a\x0C\xF8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x02sV[_\x82\x81R`\x03` R`@\x90 Ta\rRW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[a\r`\x87`\x01T\x84\x87a\x13?V[a\r\xD2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x02sV[\x81a\r\xDE\x88\x88\x88a\x13\xD9V[\x14a\x0EQW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02sV[`\x01\x82\x90U`\x02\x87\x90U_a\x0Ee\x86a\x15jV[\x90P`\x05T\x81\x14a\x0EvW`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x0E\xC6a\x0E\xC1\x86a\x11\x86V[a\x07^V[\x90P_a\x0E\xD5a\x0E\xC1\x86a\x11\x86V[\x90Pa\x0E\xE3a\x07\xE0\x82a\x1A\x15V[a\x07\xDF\x14a\x0FYW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x02sV[a\x0Fe\x82a\x07\xDFa\x19\xD5V[\x81\x14a\x0F\xD9W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x02sV[a\x0F\xE2\x85a\x15jV[a\x0F\xEB\x87a\x15jV[\x14a\x10^W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x02sV[_a\x10h\x85a\x12^V[\x90P_a\x10\x9Aa\x10w\x89a\x12^V[a\x10\x80\x8Aa\x15|V[c\xFF\xFF\xFF\xFF\x16a\x10\x8F\x8Aa\x15|V[c\xFF\xFF\xFF\xFF\x16a\x15\xAFV[\x90P\x81\x81\x83\x16\x14a\x10\xEDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[_a\x10\xF7\x89a\x15jV[\x90P\x80`\x06T\x14\x15\x80\x15a\x11!WPa\x07\xE0a\x11\x14`\x01Ta\x07^V[a\x11\x1E\x91\x90a\x1A;V[\x84\x11[\x15a\x11,W`\x06\x81\x90U[a\x118\x88\x88`\x01a\x08)V[\x99\x98PPPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\x11{W\x85\x82\x03a\x11cW`\x01\x92PPPa\x06\xE5V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x11IV[P_\x95\x94PPPPPV[_`\x02\x80\x83`@Qa\x11\x98\x91\x90a\x1ANV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x11\xB3W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\xD6\x91\x90a\x1AdV[`@Q` \x01a\x11\xE8\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\x90\x82\x90Ra\x12 \x91a\x1ANV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x12;W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x1AdV[_a\x01\xB6\x82_a\x12\x8EV[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x12\xA5a\x12\x9E\x84`Ha\x19\xD5V[\x85\x90a\x16AV[`\xE8\x1C\x90P_\x84a\x12\xB7\x85`Ka\x19\xD5V[\x81Q\x81\x10a\x12\xC7Wa\x12\xC7a\x1A{V[\x01` \x01Q`\xF8\x1C\x90P_a\x12\xF9\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x13\x0C`\x03\x84a\x1A\xA8V[`\xFF\x16\x90Pa\x13\x1D\x81a\x01\0a\x1B\xA4V[a\x04\xEC\x90\x83a\x1B\xAFV[_a\x01\xB3a\x136\x83`\x04a\x19\xD5V[\x84\x01` \x01Q\x90V[_\x83\x85\x14\x80\x15a\x13NWP\x82\x85\x14[\x15a\x13[WP`\x01a\x03zV[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x13\xA3W\x89\x83\x14a\x13\x82W_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x13\x9BW_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x13aV[P\x82\x84\x03a\x13\xB7W_\x94PPPPPa\x03zV[\x80\x82\x14a\x13\xCAW_\x94PPPPPa\x03zV[P`\x01\x98\x97PPPPPPPPV[__a\x13\xE4\x85a\x07^V[\x90P_a\x13\xF3a\x0E\xC1\x86a\x11\x86V[\x90P_a\x14\x02a\x0E\xC1\x86a\x11\x86V[\x90P\x82\x82\x10\x15\x80\x15a\x14\x14WP\x82\x81\x10\x15[a\x14\x86W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02sV[_a\x14\x93a\x07\xE0\x85a\x1A\x15V[a\x14\x9F\x85a\x07\xE0a\x19\xD5V[a\x14\xA9\x91\x90a\x1A;V[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x14\xBBWP\x80[\x15a\x14\xD6Wa\x14\xC9\x89a\x11\x86V[\x96PPPPPPPa\x06\xE5V[\x81\x80\x15a\x14\xE1WP\x80\x15[\x15a\x14\xEFWa\x14\xC9\x88a\x11\x86V[\x81\x80\x15a\x14\xF9WP\x80[\x15a\x15\x1DW\x83\x85\x10\x15a\x15\x14Wa\x15\x0F\x88a\x11\x86V[a\x14\xC9V[a\x14\xC9\x89a\x11\x86V[a\x15&\x88a\x15jV[a\x152a\x07\xE0\x86a\x1A\x15V[a\x15<\x91\x90a\x1B\xAFV[a\x15E\x8Aa\x15jV[a\x15Qa\x07\xE0\x88a\x1A\x15V[a\x15[\x91\x90a\x1B\xAFV[\x10\x15a\x15\x14Wa\x14\xC9\x88a\x11\x86V[_a\x01\xB6a\x15w\x83a\x12^V[a\x16OV[_a\x01\xB6a\x15\x89\x83a\x16vV[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x15\xBB\x83\x85a\x16\x82V[\x90Pa\x15\xCBb\x12u\0`\x04a\x16\xDDV[\x81\x10\x15a\x15\xE3Wa\x15\xE0b\x12u\0`\x04a\x16\xDDV[\x90P[a\x15\xF1b\x12u\0`\x04a\x16\xE8V[\x81\x11\x15a\x16\tWa\x16\x06b\x12u\0`\x04a\x16\xE8V[\x90P[_a\x16!\x82a\x16\x1B\x88b\x01\0\0a\x16\xDDV[\x90a\x16\xE8V[\x90Pa\x167b\x01\0\0a\x16\x1B\x83b\x12u\0a\x16\xDDV[\x96\x95PPPPPPV[_a\x01\xB3\x83\x83\x01` \x01Q\x90V[_a\x01\xB6{\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\x83a\x16\xDDV[_a\x01\xB6\x82`Da\x16AV[_\x82\x82\x11\x15a\x16\xD3W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x02sV[a\x01\xB3\x82\x84a\x1A;V[_a\x01\xB3\x82\x84a\x1A(V[_\x82_\x03a\x16\xF7WP_a\x01\xB6V[a\x17\x01\x82\x84a\x1B\xAFV[\x90P\x81a\x17\x0E\x84\x83a\x1A(V[\x14a\x01\xB6W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x02sV[__`@\x83\x85\x03\x12\x15a\x17lW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x17\x8BW__\xFD[P5\x91\x90PV[__\x83`\x1F\x84\x01\x12a\x17\xA2W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17\xB9W__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x17\xD0W__\xFD[\x92P\x92\x90PV[____`@\x85\x87\x03\x12\x15a\x17\xEAW__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\0W__\xFD[a\x18\x0C\x87\x82\x88\x01a\x17\x92V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18+W__\xFD[a\x187\x87\x82\x88\x01a\x17\x92V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x18XW__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18uW__\xFD[a\x18\x81\x89\x82\x8A\x01a\x17\x92V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\xA0W__\xFD[a\x18\xAC\x89\x82\x8A\x01a\x17\x92V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x18\xD9W__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\xEFW__\xFD[a\x18\xFB\x89\x82\x8A\x01a\x17\x92V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x19\x1AW__\xFD[a\x19&\x89\x82\x8A\x01a\x17\x92V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x19EW__\xFD[a\x19Q\x89\x82\x8A\x01a\x17\x92V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[___``\x84\x86\x03\x12\x15a\x19uW__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\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[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x01\xB6Wa\x01\xB6a\x19\x8CV[\x80\x82\x01\x80\x82\x11\x15a\x01\xB6Wa\x01\xB6a\x19\x8CV[\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\x1A#Wa\x1A#a\x19\xE8V[P\x06\x90V[_\x82a\x1A6Wa\x1A6a\x19\xE8V[P\x04\x90V[\x81\x81\x03\x81\x81\x11\x15a\x01\xB6Wa\x01\xB6a\x19\x8CV[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x1AtW__\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[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x01\xB6Wa\x01\xB6a\x19\x8CV[`\x01\x81[`\x01\x84\x11\x15a\x1A\xFCW\x80\x85\x04\x81\x11\x15a\x1A\xE0Wa\x1A\xE0a\x19\x8CV[`\x01\x84\x16\x15a\x1A\xEEW\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x1A\xC5V[\x93P\x93\x91PPV[_\x82a\x1B\x12WP`\x01a\x01\xB6V[\x81a\x1B\x1EWP_a\x01\xB6V[\x81`\x01\x81\x14a\x1B4W`\x02\x81\x14a\x1B>Wa\x1BZV[`\x01\x91PPa\x01\xB6V[`\xFF\x84\x11\x15a\x1BOWa\x1BOa\x19\x8CV[PP`\x01\x82\x1Ba\x01\xB6V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x1B}WP\x81\x81\na\x01\xB6V[a\x1B\x89_\x19\x84\x84a\x1A\xC1V[\x80_\x19\x04\x82\x11\x15a\x1B\x9CWa\x1B\x9Ca\x19\x8CV[\x02\x93\x92PPPV[_a\x01\xB3\x83\x83a\x1B\x04V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x01\xB6Wa\x01\xB6a\x19\x8CV\xFE\xA2dipfsX\"\x12 >\xFE\xC4\xD8.\xBD\xB8\x7F\rf\xA3\x8Eq\x02fi!\xFA\x84\xD6#\xE9\xB3\x1DSyJ\xB72Y\xF5\x83dsolcC\0\x08\x1C\x003", + b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa!:8\x03\x80a!:\x839\x81\x01`@\x81\x90Ra\0.\x91a\x02\x9FV[\x82Q`P\x14a\0wW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x11`$\x82\x01RpBad genesis block`x\x1B`D\x82\x01R`d\x01`@Q\x80\x91\x03\x90\xFD[_a\0\x81\x84a\0\xDAV[_\x81\x81U`\x01\x82\x90U`\x02\x82\x90U\x81\x81R`\x04` R`@\x90 \x84\x90U\x90Pa\0\xACa\x07\xE0\x84a\x03rV[a\0\xB6\x90\x84a\x03\x99V[_\x83\x81R`\x04` R`@\x90 Ua\0\xCD\x84a\x01\x9AV[`\x05UPa\x051\x92PPPV[_`\x02\x80\x83`@Qa\0\xEC\x91\x90a\x03\xACV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\x07W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01*\x91\x90a\x03\xC2V[`@Q` \x01a\x01<\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x01V\x91a\x03\xACV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01qW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\x94\x91\x90a\x03\xC2V[\x92\x91PPV[_a\x01\x94a\x01\xA7\x83a\x01\xACV[a\x01\xB7V[_a\x01\x94\x82\x82a\x01\xC7V[_a\x01\x94a\xFF\xFF`\xD0\x1B\x83a\x02kV[_\x80a\x01\xDEa\x01\xD7\x84`Ha\x03\xD9V[\x85\x90a\x02}V[`\xE8\x1C\x90P_\x84a\x01\xF0\x85`Ka\x03\xD9V[\x81Q\x81\x10a\x02\0Wa\x02\0a\x03\xECV[\x01` \x01Q`\xF8\x1C\x90P_a\x022\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x02E`\x03\x84a\x04\0V[`\xFF\x16\x90Pa\x02V\x81a\x01\0a\x04\xFCV[a\x02`\x90\x83a\x05\x07V[\x97\x96PPPPPPPV[_a\x02v\x82\x84a\x05\x1EV[\x93\x92PPPV[_a\x02v\x83\x83\x01` \x01Q\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x02\xB1W__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x02\xC6W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x02\xD6W__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x02\xEFWa\x02\xEFa\x02\x8BV[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x03\x1DWa\x03\x1Da\x02\x8BV[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x034W__\xFD[\x81` \x84\x01` \x83\x01^_` \x92\x82\x01\x83\x01R\x90\x86\x01Q`@\x90\x96\x01Q\x90\x97\x95\x96P\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x03\x80Wa\x03\x80a\x03^V[P\x06\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x01\x94Wa\x01\x94a\x03\x85V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x03\xD2W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x01\x94Wa\x01\x94a\x03\x85V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x01\x94Wa\x01\x94a\x03\x85V[`\x01\x81[`\x01\x84\x11\x15a\x04TW\x80\x85\x04\x81\x11\x15a\x048Wa\x048a\x03\x85V[`\x01\x84\x16\x15a\x04FW\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x04\x1DV[\x93P\x93\x91PPV[_\x82a\x04jWP`\x01a\x01\x94V[\x81a\x04vWP_a\x01\x94V[\x81`\x01\x81\x14a\x04\x8CW`\x02\x81\x14a\x04\x96Wa\x04\xB2V[`\x01\x91PPa\x01\x94V[`\xFF\x84\x11\x15a\x04\xA7Wa\x04\xA7a\x03\x85V[PP`\x01\x82\x1Ba\x01\x94V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x04\xD5WP\x81\x81\na\x01\x94V[a\x04\xE1_\x19\x84\x84a\x04\x19V[\x80_\x19\x04\x82\x11\x15a\x04\xF4Wa\x04\xF4a\x03\x85V[\x02\x93\x92PPPV[_a\x02v\x83\x83a\x04\\V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x01\x94Wa\x01\x94a\x03\x85V[_\x82a\x05,Wa\x05,a\x03^V[P\x04\x90V[a\x1B\xFC\x80a\x05>_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xCFW_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0}W\x80c\xB9\x85b\x1A\x11a\0XW\x80c\xB9\x85b\x1A\x14a\x01\x86W\x80c\xC5\x82B\xCD\x14a\x01\x99W\x80c\xE3\xD8\xD8\xD8\x14a\x01\xA1W__\xFD[\x80cp\xD5<\x18\x14a\x01CW\x80ct\xC3\xA3\xA9\x14a\x01`W\x80c\x7F\xA67\xFC\x14a\x01sW__\xFD[\x80c0\x01{;\x11a\0\xADW\x80c0\x01{;\x14a\0\xFAW\x80c`\xB5\xC3\x90\x14a\x01\rW\x80ce\xDAA\xB9\x14a\x01 W__\xFD[\x80c\x117d\xBE\x14a\0\xD3W\x80c\x19\x10\xD9s\x14a\0\xEAW\x80c+\x97\xBE$\x14a\0\xF2W[__\xFD[`\x05T[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[`\x01Ta\0\xD7V[`\x06Ta\0\xD7V[a\0\xD7a\x01\x086`\x04a\x17[V[a\x01\xA8V[a\0\xD7a\x01\x1B6`\x04a\x17{V[a\x01\xBCV[a\x013a\x01.6`\x04a\x17\xD7V[a\x01\xC6V[`@Q\x90\x15\x15\x81R` \x01a\0\xE1V[a\x01K`\x04\x81V[`@Qc\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\0\xE1V[a\x013a\x01n6`\x04a\x18CV[a\x03\x82V[a\x013a\x01\x816`\x04a\x18\xC4V[a\x04\xF7V[a\x013a\x01\x946`\x04a\x19cV[a\x06\xD6V[`\x02Ta\0\xD7V[_Ta\0\xD7V[_a\x01\xB3\x83\x83a\x06\xECV[\x90P[\x92\x91PPV[_a\x01\xB6\x82a\x07^V[_a\x02\x05\x83\x83\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\x08\x0C\x92PPPV[a\x02|W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`+`$\x82\x01R\x7FHeader array length must be divi`D\x82\x01R\x7Fsible by 80\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\x02\xBA\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\x08\"\x92PPPV[a\x03\x06W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7FAnchor must be 80 bytes\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[a\x03w\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\x91RPP`@\x80Q` `\x1F\x89\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x87\x81R\x92P\x87\x91P\x86\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x82\x90RP\x92Pa\x08)\x91PPV[\x90P[\x94\x93PPPPV[_a\x03\xC1\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\x91RPa\x08\"\x92PPPV[\x80\x15a\x04\x06WPa\x04\x06\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\x91RPa\x08\"\x92PPPV[a\x04xW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`.`$\x82\x01R\x7FBad args. Check header and array`D\x82\x01R\x7F byte lengths.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02sV[a\x04\xEC\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_\x92\x01\x91\x90\x91RPP`@\x80Q` `\x1F\x8B\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x89\x81R\x92P\x89\x91P\x88\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RP\x88\x92Pa\x0C\x16\x91PPV[\x97\x96PPPPPPPV[_a\x056\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\x91RPa\x08\"\x92PPPV[\x80\x15a\x05{WPa\x05{\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\x08\"\x92PPPV[\x80\x15a\x05\xC0WPa\x05\xC0\x83\x83\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\x08\x0C\x92PPPV[a\x062W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`.`$\x82\x01R\x7FBad args. Check header and array`D\x82\x01R\x7F byte lengths.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02sV[a\x04\xEC\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\x91RPP`@\x80Q` `\x1F\x8B\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x89\x81R\x92P\x89\x91P\x88\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RPP`@\x80Q` `\x1F\x8A\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x88\x81R\x92P\x88\x91P\x87\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RPa\x0E\xB3\x92PPPV[_a\x06\xE2\x84\x84\x84a\x11EV[\x90P[\x93\x92PPPV[_\x82\x81[\x83\x81\x10\x15a\x07\x10W_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x06\xF0V[P\x80a\x01\xB3W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[_\x80\x82\x81[a\x07o`\x04`\x01a\x19\xB9V[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x07\xC3W_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\x07\xA8W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x07\xBBV[a\x07\xB2\x81\x84a\x19\xD5V[\x95\x94PPPPPV[`\x01\x01a\x07cV[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[_`P\x82Qa\x08\x1B\x91\x90a\x1A\x15V[\x15\x92\x91PPV[Q`P\x14\x90V[__a\x084\x85a\x11\x86V[\x90P_a\x08@\x82a\x07^V[\x90P_a\x08L\x86a\x12^V[\x90P\x84\x80a\x08aWP\x80a\x08_\x88a\x12^V[\x14[a\x08\xD2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x02sV[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x0B\xD3Wa\x08\xED`P\x82a\x1A(V[a\x08\xF8\x90`\x01a\x19\xD5V[a\t\x02\x90\x87a\x19\xD5V[\x93Pa\t\x10\x8A\x82`Pa\x12iV[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\n\xE6W\x84a\nf\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\n\xB4W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\n\xCF`\x04\x85a\x1A\x15V[_\x03a\n\xE6W_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\n\xF1\x8B\x83a\x12\x8EV[\x14a\x0B>W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[\x86a\x0BI\x8B\x83a\x13'V[\x14a\x0B\xBCW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x02sV[\x82\x96P`P\x81a\x0B\xCC\x91\x90a\x19\xD5V[\x90Pa\x08\xDAV[P\x81a\x0B\xDE\x8Ba\x11\x86V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x0C\x8FW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02sV[_a\x0C\x99\x84a\x11\x86V[\x90P_a\x0C\xA5\x86a\x11\x86V[\x90P`\x01T\x81\x14a\x0C\xF8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x02sV[_\x82\x81R`\x03` R`@\x90 Ta\rRW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[a\r`\x87`\x01T\x84\x87a\x13?V[a\r\xD2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x02sV[\x81a\r\xDE\x88\x88\x88a\x13\xD9V[\x14a\x0EQW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02sV[`\x01\x82\x90U`\x02\x87\x90U_a\x0Ee\x86a\x15jV[\x90P`\x05T\x81\x14a\x0EvW`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x0E\xC6a\x0E\xC1\x86a\x11\x86V[a\x07^V[\x90P_a\x0E\xD5a\x0E\xC1\x86a\x11\x86V[\x90Pa\x0E\xE3a\x07\xE0\x82a\x1A\x15V[a\x07\xDF\x14a\x0FYW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x02sV[a\x0Fe\x82a\x07\xDFa\x19\xD5V[\x81\x14a\x0F\xD9W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x02sV[a\x0F\xE2\x85a\x15jV[a\x0F\xEB\x87a\x15jV[\x14a\x10^W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x02sV[_a\x10h\x85a\x12^V[\x90P_a\x10\x9Aa\x10w\x89a\x12^V[a\x10\x80\x8Aa\x15|V[c\xFF\xFF\xFF\xFF\x16a\x10\x8F\x8Aa\x15|V[c\xFF\xFF\xFF\xFF\x16a\x15\xAFV[\x90P\x81\x81\x83\x16\x14a\x10\xEDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[_a\x10\xF7\x89a\x15jV[\x90P\x80`\x06T\x14\x15\x80\x15a\x11!WPa\x07\xE0a\x11\x14`\x01Ta\x07^V[a\x11\x1E\x91\x90a\x1A;V[\x84\x11[\x15a\x11,W`\x06\x81\x90U[a\x118\x88\x88`\x01a\x08)V[\x99\x98PPPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\x11{W\x85\x82\x03a\x11cW`\x01\x92PPPa\x06\xE5V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x11IV[P_\x95\x94PPPPPV[_`\x02\x80\x83`@Qa\x11\x98\x91\x90a\x1ANV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x11\xB3W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\xD6\x91\x90a\x1AdV[`@Q` \x01a\x11\xE8\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\x90\x82\x90Ra\x12 \x91a\x1ANV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x12;W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x1AdV[_a\x01\xB6\x82_a\x12\x8EV[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x12\xA5a\x12\x9E\x84`Ha\x19\xD5V[\x85\x90a\x16AV[`\xE8\x1C\x90P_\x84a\x12\xB7\x85`Ka\x19\xD5V[\x81Q\x81\x10a\x12\xC7Wa\x12\xC7a\x1A{V[\x01` \x01Q`\xF8\x1C\x90P_a\x12\xF9\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x13\x0C`\x03\x84a\x1A\xA8V[`\xFF\x16\x90Pa\x13\x1D\x81a\x01\0a\x1B\xA4V[a\x04\xEC\x90\x83a\x1B\xAFV[_a\x01\xB3a\x136\x83`\x04a\x19\xD5V[\x84\x01` \x01Q\x90V[_\x83\x85\x14\x80\x15a\x13NWP\x82\x85\x14[\x15a\x13[WP`\x01a\x03zV[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x13\xA3W\x89\x83\x14a\x13\x82W_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x13\x9BW_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x13aV[P\x82\x84\x03a\x13\xB7W_\x94PPPPPa\x03zV[\x80\x82\x14a\x13\xCAW_\x94PPPPPa\x03zV[P`\x01\x98\x97PPPPPPPPV[__a\x13\xE4\x85a\x07^V[\x90P_a\x13\xF3a\x0E\xC1\x86a\x11\x86V[\x90P_a\x14\x02a\x0E\xC1\x86a\x11\x86V[\x90P\x82\x82\x10\x15\x80\x15a\x14\x14WP\x82\x81\x10\x15[a\x14\x86W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02sV[_a\x14\x93a\x07\xE0\x85a\x1A\x15V[a\x14\x9F\x85a\x07\xE0a\x19\xD5V[a\x14\xA9\x91\x90a\x1A;V[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x14\xBBWP\x80[\x15a\x14\xD6Wa\x14\xC9\x89a\x11\x86V[\x96PPPPPPPa\x06\xE5V[\x81\x80\x15a\x14\xE1WP\x80\x15[\x15a\x14\xEFWa\x14\xC9\x88a\x11\x86V[\x81\x80\x15a\x14\xF9WP\x80[\x15a\x15\x1DW\x83\x85\x10\x15a\x15\x14Wa\x15\x0F\x88a\x11\x86V[a\x14\xC9V[a\x14\xC9\x89a\x11\x86V[a\x15&\x88a\x15jV[a\x152a\x07\xE0\x86a\x1A\x15V[a\x15<\x91\x90a\x1B\xAFV[a\x15E\x8Aa\x15jV[a\x15Qa\x07\xE0\x88a\x1A\x15V[a\x15[\x91\x90a\x1B\xAFV[\x10\x15a\x15\x14Wa\x14\xC9\x88a\x11\x86V[_a\x01\xB6a\x15w\x83a\x12^V[a\x16OV[_a\x01\xB6a\x15\x89\x83a\x16vV[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x15\xBB\x83\x85a\x16\x82V[\x90Pa\x15\xCBb\x12u\0`\x04a\x16\xDDV[\x81\x10\x15a\x15\xE3Wa\x15\xE0b\x12u\0`\x04a\x16\xDDV[\x90P[a\x15\xF1b\x12u\0`\x04a\x16\xE8V[\x81\x11\x15a\x16\tWa\x16\x06b\x12u\0`\x04a\x16\xE8V[\x90P[_a\x16!\x82a\x16\x1B\x88b\x01\0\0a\x16\xDDV[\x90a\x16\xE8V[\x90Pa\x167b\x01\0\0a\x16\x1B\x83b\x12u\0a\x16\xDDV[\x96\x95PPPPPPV[_a\x01\xB3\x83\x83\x01` \x01Q\x90V[_a\x01\xB6{\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\x83a\x16\xDDV[_a\x01\xB6\x82`Da\x16AV[_\x82\x82\x11\x15a\x16\xD3W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x02sV[a\x01\xB3\x82\x84a\x1A;V[_a\x01\xB3\x82\x84a\x1A(V[_\x82_\x03a\x16\xF7WP_a\x01\xB6V[a\x17\x01\x82\x84a\x1B\xAFV[\x90P\x81a\x17\x0E\x84\x83a\x1A(V[\x14a\x01\xB6W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x02sV[__`@\x83\x85\x03\x12\x15a\x17lW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x17\x8BW__\xFD[P5\x91\x90PV[__\x83`\x1F\x84\x01\x12a\x17\xA2W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17\xB9W__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x17\xD0W__\xFD[\x92P\x92\x90PV[____`@\x85\x87\x03\x12\x15a\x17\xEAW__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\0W__\xFD[a\x18\x0C\x87\x82\x88\x01a\x17\x92V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18+W__\xFD[a\x187\x87\x82\x88\x01a\x17\x92V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x18XW__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18uW__\xFD[a\x18\x81\x89\x82\x8A\x01a\x17\x92V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\xA0W__\xFD[a\x18\xAC\x89\x82\x8A\x01a\x17\x92V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x18\xD9W__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\xEFW__\xFD[a\x18\xFB\x89\x82\x8A\x01a\x17\x92V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x19\x1AW__\xFD[a\x19&\x89\x82\x8A\x01a\x17\x92V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x19EW__\xFD[a\x19Q\x89\x82\x8A\x01a\x17\x92V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[___``\x84\x86\x03\x12\x15a\x19uW__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\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[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x01\xB6Wa\x01\xB6a\x19\x8CV[\x80\x82\x01\x80\x82\x11\x15a\x01\xB6Wa\x01\xB6a\x19\x8CV[\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\x1A#Wa\x1A#a\x19\xE8V[P\x06\x90V[_\x82a\x1A6Wa\x1A6a\x19\xE8V[P\x04\x90V[\x81\x81\x03\x81\x81\x11\x15a\x01\xB6Wa\x01\xB6a\x19\x8CV[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x1AtW__\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[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x01\xB6Wa\x01\xB6a\x19\x8CV[`\x01\x81[`\x01\x84\x11\x15a\x1A\xFCW\x80\x85\x04\x81\x11\x15a\x1A\xE0Wa\x1A\xE0a\x19\x8CV[`\x01\x84\x16\x15a\x1A\xEEW\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x1A\xC5V[\x93P\x93\x91PPV[_\x82a\x1B\x12WP`\x01a\x01\xB6V[\x81a\x1B\x1EWP_a\x01\xB6V[\x81`\x01\x81\x14a\x1B4W`\x02\x81\x14a\x1B>Wa\x1BZV[`\x01\x91PPa\x01\xB6V[`\xFF\x84\x11\x15a\x1BOWa\x1BOa\x19\x8CV[PP`\x01\x82\x1Ba\x01\xB6V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x1B}WP\x81\x81\na\x01\xB6V[a\x1B\x89_\x19\x84\x84a\x1A\xC1V[\x80_\x19\x04\x82\x11\x15a\x1B\x9CWa\x1B\x9Ca\x19\x8CV[\x02\x93\x92PPPV[_a\x01\xB3\x83\x83a\x1B\x04V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x01\xB6Wa\x01\xB6a\x19\x8CV\xFE\xA2dipfsX\"\x12 \xC2\xB989`HD\xCC7\x9C\xB1\x04\xC6/d\xCA\x91\xFD\xF4&\x07@\xC2\x05\xE9'\xCB\x05\xD6<\xAC.dsolcC\0\x08\x1C\x003", ); /// The runtime bytecode of the contract, as deployed on the network. /// /// ```text - ///0x608060405234801561000f575f5ffd5b50600436106100cf575f3560e01c806370d53c181161007d578063b985621a11610058578063b985621a14610186578063c58242cd14610199578063e3d8d8d8146101a1575f5ffd5b806370d53c181461014357806374c3a3a9146101605780637fa637fc14610173575f5ffd5b806330017b3b116100ad57806330017b3b146100fa57806360b5c3901461010d57806365da41b914610120575f5ffd5b8063113764be146100d35780631910d973146100ea5780632b97be24146100f2575b5f5ffd5b6005545b6040519081526020015b60405180910390f35b6001546100d7565b6006546100d7565b6100d761010836600461175b565b6101a8565b6100d761011b36600461177b565b6101bc565b61013361012e3660046117d7565b6101c6565b60405190151581526020016100e1565b61014b600481565b60405163ffffffff90911681526020016100e1565b61013361016e366004611843565b610382565b6101336101813660046118c4565b6104f7565b610133610194366004611963565b6106d6565b6002546100d7565b5f546100d7565b5f6101b383836106ec565b90505b92915050565b5f6101b68261075e565b5f61020583838080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525061080c92505050565b61027c5760405162461bcd60e51b815260206004820152602b60248201527f486561646572206172726179206c656e677468206d757374206265206469766960448201527f7369626c6520627920383000000000000000000000000000000000000000000060648201526084015b60405180910390fd5b6102ba85858080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525061082292505050565b6103065760405162461bcd60e51b815260206004820152601760248201527f416e63686f72206d7573742062652038302062797465730000000000000000006044820152606401610273565b61037785858080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525050604080516020601f890181900481028201810190925287815292508791508690819084018382808284375f9201829052509250610829915050565b90505b949350505050565b5f6103c184848080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525061082292505050565b8015610406575061040686868080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525061082292505050565b6104785760405162461bcd60e51b815260206004820152602e60248201527f42616420617267732e20436865636b2068656164657220616e6420617272617960448201527f2062797465206c656e677468732e0000000000000000000000000000000000006064820152608401610273565b6104ec8787878080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525050604080516020601f8b0181900481028201810190925289815292508991508890819084018382808284375f92019190915250889250610c16915050565b979650505050505050565b5f61053687878080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525061082292505050565b801561057b575061057b85858080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525061082292505050565b80156105c057506105c083838080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525061080c92505050565b6106325760405162461bcd60e51b815260206004820152602e60248201527f42616420617267732e20436865636b2068656164657220616e6420617272617960448201527f2062797465206c656e677468732e0000000000000000000000000000000000006064820152608401610273565b6104ec87878080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525050604080516020601f8b0181900481028201810190925289815292508991508890819084018382808284375f9201919091525050604080516020601f8a0181900481028201810190925288815292508891508790819084018382808284375f92019190915250610eb392505050565b5f6106e2848484611145565b90505b9392505050565b5f82815b83811015610710575f9182526003602052604090912054906001016106f0565b50806101b35760405162461bcd60e51b815260206004820152601060248201527f556e6b6e6f776e20616e636573746f72000000000000000000000000000000006044820152606401610273565b5f8082815b61076f600460016119b9565b63ffffffff168110156107c3575f8281526004602052604081205493508390036107a8575f9182526003602052604090912054906107bb565b6107b281846119d5565b95945050505050565b600101610763565b5060405162461bcd60e51b815260206004820152600d60248201527f556e6b6e6f776e20626c6f636b000000000000000000000000000000000000006044820152606401610273565b5f6050825161081b9190611a15565b1592915050565b5160501490565b5f5f61083485611186565b90505f6108408261075e565b90505f61084c8661125e565b9050848061086157508061085f8861125e565b145b6108d25760405162461bcd60e51b8152602060048201526024808201527f556e6578706563746564207265746172676574206f6e2065787465726e616c2060448201527f63616c6c000000000000000000000000000000000000000000000000000000006064820152608401610273565b85515f908190815b81811015610bd3576108ed605082611a28565b6108f89060016119d5565b61090290876119d5565b93506109108a826050611269565b5f81815260036020526040902054909350610ae65784610a66845f8190506008817eff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff16901b600882901c7eff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff161790506010817dffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff16901b601082901c7dffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff161790506020817bffffffff00000000ffffffff00000000ffffffff00000000ffffffff16901b602082901c7bffffffff00000000ffffffff00000000ffffffff00000000ffffffff1617905060408177ffffffffffffffff0000000000000000ffffffffffffffff16901b604082901c77ffffffffffffffff0000000000000000ffffffffffffffff16179050608081901b608082901c179050919050565b1115610ab45760405162461bcd60e51b815260206004820152601b60248201527f48656164657220776f726b20697320696e73756666696369656e7400000000006044820152606401610273565b5f838152600360205260409020879055610acf600485611a15565b5f03610ae6575f8381526004602052604090208490555b84610af18b8361128e565b14610b3e5760405162461bcd60e51b815260206004820152601b60248201527f546172676574206368616e67656420756e65787065637465646c7900000000006044820152606401610273565b86610b498b83611327565b14610bbc5760405162461bcd60e51b815260206004820152602660248201527f4865616465727320646f206e6f7420666f726d206120636f6e73697374656e7460448201527f20636861696e00000000000000000000000000000000000000000000000000006064820152608401610273565b829650605081610bcc91906119d5565b90506108da565b5081610bde8b611186565b6040517ff90e4f1d9cd0dd55e339411cbc9b152482307c3a23ed64715e4a2858f641a3f5905f90a35060019998505050505050505050565b5f6107e0821115610c8f5760405162461bcd60e51b815260206004820152603360248201527f526571756573746564206c696d69742069732067726561746572207468616e2060448201527f3120646966666963756c747920706572696f64000000000000000000000000006064820152608401610273565b5f610c9984611186565b90505f610ca586611186565b90506001548114610cf85760405162461bcd60e51b815260206004820181905260248201527f50617373656420696e2062657374206973206e6f742062657374206b6e6f776e6044820152606401610273565b5f82815260036020526040902054610d525760405162461bcd60e51b815260206004820152601360248201527f4e6577206265737420697320756e6b6e6f776e000000000000000000000000006044820152606401610273565b610d6087600154848761133f565b610dd25760405162461bcd60e51b815260206004820152602960248201527f416e636573746f72206d75737420626520686561766965737420636f6d6d6f6e60448201527f20616e636573746f7200000000000000000000000000000000000000000000006064820152608401610273565b81610dde8888886113d9565b14610e515760405162461bcd60e51b815260206004820152603360248201527f4e65772062657374206861736820646f6573206e6f742068617665206d6f726560448201527f20776f726b207468616e2070726576696f7573000000000000000000000000006064820152608401610273565b600182905560028790555f610e658661156a565b90506005548114610e765760058190555b8783837f3cc13de64df0f0239626235c51a2da251bbc8c85664ecce39263da3ee03f606c60405160405180910390a4506001979650505050505050565b5f5f610ec6610ec186611186565b61075e565b90505f610ed5610ec186611186565b9050610ee36107e082611a15565b6107df14610f595760405162461bcd60e51b815260206004820152603d60248201527f4d7573742070726f7669646520746865206c61737420686561646572206f662060448201527f74686520636c6f73696e6720646966666963756c747920706572696f640000006064820152608401610273565b610f65826107df6119d5565b8114610fd95760405162461bcd60e51b815260206004820152602860248201527f4d7573742070726f766964652065786163746c79203120646966666963756c7460448201527f7920706572696f640000000000000000000000000000000000000000000000006064820152608401610273565b610fe28561156a565b610feb8761156a565b1461105e5760405162461bcd60e51b815260206004820152602760248201527f506572696f642068656164657220646966666963756c7469657320646f206e6f60448201527f74206d61746368000000000000000000000000000000000000000000000000006064820152608401610273565b5f6110688561125e565b90505f61109a6110778961125e565b6110808a61157c565b63ffffffff1661108f8a61157c565b63ffffffff166115af565b905081818316146110ed5760405162461bcd60e51b815260206004820152601960248201527f496e76616c69642072657461726765742070726f7669646564000000000000006044820152606401610273565b5f6110f78961156a565b9050806006541415801561112157506107e061111460015461075e565b61111e9190611a3b565b84115b1561112c5760068190555b61113888886001610829565b9998505050505050505050565b5f82815b8381101561117b57858203611163576001925050506106e5565b5f918252600360205260409091205490600101611149565b505f95945050505050565b5f600280836040516111989190611a4e565b602060405180830381855afa1580156111b3573d5f5f3e3d5ffd5b5050506040513d601f19601f820116820180604052508101906111d69190611a64565b6040516020016111e891815260200190565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529082905261122091611a4e565b602060405180830381855afa15801561123b573d5f5f3e3d5ffd5b5050506040513d601f19601f820116820180604052508101906101b69190611a64565b5f6101b6825f61128e565b5f60205f8385602001870160025afa5060205f60205f60025afa50505f519392505050565b5f806112a561129e8460486119d5565b8590611641565b60e81c90505f846112b785604b6119d5565b815181106112c7576112c7611a7b565b016020015160f81c90505f6112f9835f60108262ffffff16901c8261ff001660108462ffffff16901b17179050919050565b62ffffff1690505f61130c600384611aa8565b60ff16905061131d81610100611ba4565b6104ec9083611baf565b5f6101b36113368360046119d5565b84016020015190565b5f838514801561134e57508285145b1561135b5750600161037a565b838381815f5b868110156113a357898314611382575f838152600360205260409020549294505b89821461139b575f828152600360205260409020549193505b600101611361565b508284036113b7575f94505050505061037a565b8082146113ca575f94505050505061037a565b50600198975050505050505050565b5f5f6113e48561075e565b90505f6113f3610ec186611186565b90505f611402610ec186611186565b90508282101580156114145750828110155b6114865760405162461bcd60e51b815260206004820152603060248201527f412064657363656e64616e74206865696768742069732062656c6f772074686560448201527f20616e636573746f7220686569676874000000000000000000000000000000006064820152608401610273565b5f6114936107e085611a15565b61149f856107e06119d5565b6114a99190611a3b565b90508083108183108115826114bb5750805b156114d6576114c989611186565b96505050505050506106e5565b8180156114e1575080155b156114ef576114c988611186565b8180156114f95750805b1561151d57838510156115145761150f88611186565b6114c9565b6114c989611186565b6115268861156a565b6115326107e086611a15565b61153c9190611baf565b6115458a61156a565b6115516107e088611a15565b61155b9190611baf565b1015611514576114c988611186565b5f6101b66115778361125e565b61164f565b5f6101b661158983611676565b60d881901c63ff00ff001662ff00ff60e89290921c9190911617601081811b91901c1790565b5f806115bb8385611682565b90506115cb6212750060046116dd565b8110156115e3576115e06212750060046116dd565b90505b6115f16212750060046116e8565b811115611609576116066212750060046116e8565b90505b5f6116218261161b88620100006116dd565b906116e8565b90506116376201000061161b83621275006116dd565b9695505050505050565b5f6101b38383016020015190565b5f6101b67bffff0000000000000000000000000000000000000000000000000000836116dd565b5f6101b6826044611641565b5f828211156116d35760405162461bcd60e51b815260206004820152601d60248201527f556e646572666c6f7720647572696e67207375627472616374696f6e2e0000006044820152606401610273565b6101b38284611a3b565b5f6101b38284611a28565b5f825f036116f757505f6101b6565b6117018284611baf565b90508161170e8483611a28565b146101b65760405162461bcd60e51b815260206004820152601f60248201527f4f766572666c6f7720647572696e67206d756c7469706c69636174696f6e2e006044820152606401610273565b5f5f6040838503121561176c575f5ffd5b50508035926020909101359150565b5f6020828403121561178b575f5ffd5b5035919050565b5f5f83601f8401126117a2575f5ffd5b50813567ffffffffffffffff8111156117b9575f5ffd5b6020830191508360208285010111156117d0575f5ffd5b9250929050565b5f5f5f5f604085870312156117ea575f5ffd5b843567ffffffffffffffff811115611800575f5ffd5b61180c87828801611792565b909550935050602085013567ffffffffffffffff81111561182b575f5ffd5b61183787828801611792565b95989497509550505050565b5f5f5f5f5f5f60808789031215611858575f5ffd5b86359550602087013567ffffffffffffffff811115611875575f5ffd5b61188189828a01611792565b909650945050604087013567ffffffffffffffff8111156118a0575f5ffd5b6118ac89828a01611792565b979a9699509497949695606090950135949350505050565b5f5f5f5f5f5f606087890312156118d9575f5ffd5b863567ffffffffffffffff8111156118ef575f5ffd5b6118fb89828a01611792565b909750955050602087013567ffffffffffffffff81111561191a575f5ffd5b61192689828a01611792565b909550935050604087013567ffffffffffffffff811115611945575f5ffd5b61195189828a01611792565b979a9699509497509295939492505050565b5f5f5f60608486031215611975575f5ffd5b505081359360208301359350604090920135919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b63ffffffff81811683821601908111156101b6576101b661198c565b808201808211156101b6576101b661198c565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b5f82611a2357611a236119e8565b500690565b5f82611a3657611a366119e8565b500490565b818103818111156101b6576101b661198c565b5f82518060208501845e5f920191825250919050565b5f60208284031215611a74575f5ffd5b5051919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b60ff82811682821603908111156101b6576101b661198c565b6001815b6001841115611afc57808504811115611ae057611ae061198c565b6001841615611aee57908102905b60019390931c928002611ac5565b935093915050565b5f82611b12575060016101b6565b81611b1e57505f6101b6565b8160018114611b345760028114611b3e57611b5a565b60019150506101b6565b60ff841115611b4f57611b4f61198c565b50506001821b6101b6565b5060208310610133831016604e8410600b8410161715611b7d575081810a6101b6565b611b895f198484611ac1565b805f1904821115611b9c57611b9c61198c565b029392505050565b5f6101b38383611b04565b80820281158282048414176101b6576101b661198c56fea26469706673582212203efec4d82ebdb87f0d66a38e7102666921fa84d623e9b31d53794ab73259f58364736f6c634300081c0033 + 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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\xCFW_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0}W\x80c\xB9\x85b\x1A\x11a\0XW\x80c\xB9\x85b\x1A\x14a\x01\x86W\x80c\xC5\x82B\xCD\x14a\x01\x99W\x80c\xE3\xD8\xD8\xD8\x14a\x01\xA1W__\xFD[\x80cp\xD5<\x18\x14a\x01CW\x80ct\xC3\xA3\xA9\x14a\x01`W\x80c\x7F\xA67\xFC\x14a\x01sW__\xFD[\x80c0\x01{;\x11a\0\xADW\x80c0\x01{;\x14a\0\xFAW\x80c`\xB5\xC3\x90\x14a\x01\rW\x80ce\xDAA\xB9\x14a\x01 W__\xFD[\x80c\x117d\xBE\x14a\0\xD3W\x80c\x19\x10\xD9s\x14a\0\xEAW\x80c+\x97\xBE$\x14a\0\xF2W[__\xFD[`\x05T[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[`\x01Ta\0\xD7V[`\x06Ta\0\xD7V[a\0\xD7a\x01\x086`\x04a\x17[V[a\x01\xA8V[a\0\xD7a\x01\x1B6`\x04a\x17{V[a\x01\xBCV[a\x013a\x01.6`\x04a\x17\xD7V[a\x01\xC6V[`@Q\x90\x15\x15\x81R` \x01a\0\xE1V[a\x01K`\x04\x81V[`@Qc\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\0\xE1V[a\x013a\x01n6`\x04a\x18CV[a\x03\x82V[a\x013a\x01\x816`\x04a\x18\xC4V[a\x04\xF7V[a\x013a\x01\x946`\x04a\x19cV[a\x06\xD6V[`\x02Ta\0\xD7V[_Ta\0\xD7V[_a\x01\xB3\x83\x83a\x06\xECV[\x90P[\x92\x91PPV[_a\x01\xB6\x82a\x07^V[_a\x02\x05\x83\x83\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\x08\x0C\x92PPPV[a\x02|W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`+`$\x82\x01R\x7FHeader array length must be divi`D\x82\x01R\x7Fsible by 80\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\x02\xBA\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\x08\"\x92PPPV[a\x03\x06W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7FAnchor must be 80 bytes\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[a\x03w\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\x91RPP`@\x80Q` `\x1F\x89\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x87\x81R\x92P\x87\x91P\x86\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x82\x90RP\x92Pa\x08)\x91PPV[\x90P[\x94\x93PPPPV[_a\x03\xC1\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\x91RPa\x08\"\x92PPPV[\x80\x15a\x04\x06WPa\x04\x06\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\x91RPa\x08\"\x92PPPV[a\x04xW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`.`$\x82\x01R\x7FBad args. Check header and array`D\x82\x01R\x7F byte lengths.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02sV[a\x04\xEC\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_\x92\x01\x91\x90\x91RPP`@\x80Q` `\x1F\x8B\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x89\x81R\x92P\x89\x91P\x88\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RP\x88\x92Pa\x0C\x16\x91PPV[\x97\x96PPPPPPPV[_a\x056\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\x91RPa\x08\"\x92PPPV[\x80\x15a\x05{WPa\x05{\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\x08\"\x92PPPV[\x80\x15a\x05\xC0WPa\x05\xC0\x83\x83\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\x08\x0C\x92PPPV[a\x062W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`.`$\x82\x01R\x7FBad args. Check header and array`D\x82\x01R\x7F byte lengths.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02sV[a\x04\xEC\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\x91RPP`@\x80Q` `\x1F\x8B\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x89\x81R\x92P\x89\x91P\x88\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RPP`@\x80Q` `\x1F\x8A\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x88\x81R\x92P\x88\x91P\x87\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RPa\x0E\xB3\x92PPPV[_a\x06\xE2\x84\x84\x84a\x11EV[\x90P[\x93\x92PPPV[_\x82\x81[\x83\x81\x10\x15a\x07\x10W_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x06\xF0V[P\x80a\x01\xB3W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[_\x80\x82\x81[a\x07o`\x04`\x01a\x19\xB9V[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x07\xC3W_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\x07\xA8W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x07\xBBV[a\x07\xB2\x81\x84a\x19\xD5V[\x95\x94PPPPPV[`\x01\x01a\x07cV[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[_`P\x82Qa\x08\x1B\x91\x90a\x1A\x15V[\x15\x92\x91PPV[Q`P\x14\x90V[__a\x084\x85a\x11\x86V[\x90P_a\x08@\x82a\x07^V[\x90P_a\x08L\x86a\x12^V[\x90P\x84\x80a\x08aWP\x80a\x08_\x88a\x12^V[\x14[a\x08\xD2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x02sV[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x0B\xD3Wa\x08\xED`P\x82a\x1A(V[a\x08\xF8\x90`\x01a\x19\xD5V[a\t\x02\x90\x87a\x19\xD5V[\x93Pa\t\x10\x8A\x82`Pa\x12iV[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\n\xE6W\x84a\nf\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\n\xB4W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\n\xCF`\x04\x85a\x1A\x15V[_\x03a\n\xE6W_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\n\xF1\x8B\x83a\x12\x8EV[\x14a\x0B>W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[\x86a\x0BI\x8B\x83a\x13'V[\x14a\x0B\xBCW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x02sV[\x82\x96P`P\x81a\x0B\xCC\x91\x90a\x19\xD5V[\x90Pa\x08\xDAV[P\x81a\x0B\xDE\x8Ba\x11\x86V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x0C\x8FW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02sV[_a\x0C\x99\x84a\x11\x86V[\x90P_a\x0C\xA5\x86a\x11\x86V[\x90P`\x01T\x81\x14a\x0C\xF8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x02sV[_\x82\x81R`\x03` R`@\x90 Ta\rRW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[a\r`\x87`\x01T\x84\x87a\x13?V[a\r\xD2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x02sV[\x81a\r\xDE\x88\x88\x88a\x13\xD9V[\x14a\x0EQW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02sV[`\x01\x82\x90U`\x02\x87\x90U_a\x0Ee\x86a\x15jV[\x90P`\x05T\x81\x14a\x0EvW`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x0E\xC6a\x0E\xC1\x86a\x11\x86V[a\x07^V[\x90P_a\x0E\xD5a\x0E\xC1\x86a\x11\x86V[\x90Pa\x0E\xE3a\x07\xE0\x82a\x1A\x15V[a\x07\xDF\x14a\x0FYW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x02sV[a\x0Fe\x82a\x07\xDFa\x19\xD5V[\x81\x14a\x0F\xD9W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x02sV[a\x0F\xE2\x85a\x15jV[a\x0F\xEB\x87a\x15jV[\x14a\x10^W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x02sV[_a\x10h\x85a\x12^V[\x90P_a\x10\x9Aa\x10w\x89a\x12^V[a\x10\x80\x8Aa\x15|V[c\xFF\xFF\xFF\xFF\x16a\x10\x8F\x8Aa\x15|V[c\xFF\xFF\xFF\xFF\x16a\x15\xAFV[\x90P\x81\x81\x83\x16\x14a\x10\xEDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[_a\x10\xF7\x89a\x15jV[\x90P\x80`\x06T\x14\x15\x80\x15a\x11!WPa\x07\xE0a\x11\x14`\x01Ta\x07^V[a\x11\x1E\x91\x90a\x1A;V[\x84\x11[\x15a\x11,W`\x06\x81\x90U[a\x118\x88\x88`\x01a\x08)V[\x99\x98PPPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\x11{W\x85\x82\x03a\x11cW`\x01\x92PPPa\x06\xE5V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x11IV[P_\x95\x94PPPPPV[_`\x02\x80\x83`@Qa\x11\x98\x91\x90a\x1ANV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x11\xB3W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\xD6\x91\x90a\x1AdV[`@Q` \x01a\x11\xE8\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\x90\x82\x90Ra\x12 \x91a\x1ANV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x12;W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x1AdV[_a\x01\xB6\x82_a\x12\x8EV[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x12\xA5a\x12\x9E\x84`Ha\x19\xD5V[\x85\x90a\x16AV[`\xE8\x1C\x90P_\x84a\x12\xB7\x85`Ka\x19\xD5V[\x81Q\x81\x10a\x12\xC7Wa\x12\xC7a\x1A{V[\x01` \x01Q`\xF8\x1C\x90P_a\x12\xF9\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x13\x0C`\x03\x84a\x1A\xA8V[`\xFF\x16\x90Pa\x13\x1D\x81a\x01\0a\x1B\xA4V[a\x04\xEC\x90\x83a\x1B\xAFV[_a\x01\xB3a\x136\x83`\x04a\x19\xD5V[\x84\x01` \x01Q\x90V[_\x83\x85\x14\x80\x15a\x13NWP\x82\x85\x14[\x15a\x13[WP`\x01a\x03zV[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x13\xA3W\x89\x83\x14a\x13\x82W_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x13\x9BW_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x13aV[P\x82\x84\x03a\x13\xB7W_\x94PPPPPa\x03zV[\x80\x82\x14a\x13\xCAW_\x94PPPPPa\x03zV[P`\x01\x98\x97PPPPPPPPV[__a\x13\xE4\x85a\x07^V[\x90P_a\x13\xF3a\x0E\xC1\x86a\x11\x86V[\x90P_a\x14\x02a\x0E\xC1\x86a\x11\x86V[\x90P\x82\x82\x10\x15\x80\x15a\x14\x14WP\x82\x81\x10\x15[a\x14\x86W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02sV[_a\x14\x93a\x07\xE0\x85a\x1A\x15V[a\x14\x9F\x85a\x07\xE0a\x19\xD5V[a\x14\xA9\x91\x90a\x1A;V[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x14\xBBWP\x80[\x15a\x14\xD6Wa\x14\xC9\x89a\x11\x86V[\x96PPPPPPPa\x06\xE5V[\x81\x80\x15a\x14\xE1WP\x80\x15[\x15a\x14\xEFWa\x14\xC9\x88a\x11\x86V[\x81\x80\x15a\x14\xF9WP\x80[\x15a\x15\x1DW\x83\x85\x10\x15a\x15\x14Wa\x15\x0F\x88a\x11\x86V[a\x14\xC9V[a\x14\xC9\x89a\x11\x86V[a\x15&\x88a\x15jV[a\x152a\x07\xE0\x86a\x1A\x15V[a\x15<\x91\x90a\x1B\xAFV[a\x15E\x8Aa\x15jV[a\x15Qa\x07\xE0\x88a\x1A\x15V[a\x15[\x91\x90a\x1B\xAFV[\x10\x15a\x15\x14Wa\x14\xC9\x88a\x11\x86V[_a\x01\xB6a\x15w\x83a\x12^V[a\x16OV[_a\x01\xB6a\x15\x89\x83a\x16vV[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x15\xBB\x83\x85a\x16\x82V[\x90Pa\x15\xCBb\x12u\0`\x04a\x16\xDDV[\x81\x10\x15a\x15\xE3Wa\x15\xE0b\x12u\0`\x04a\x16\xDDV[\x90P[a\x15\xF1b\x12u\0`\x04a\x16\xE8V[\x81\x11\x15a\x16\tWa\x16\x06b\x12u\0`\x04a\x16\xE8V[\x90P[_a\x16!\x82a\x16\x1B\x88b\x01\0\0a\x16\xDDV[\x90a\x16\xE8V[\x90Pa\x167b\x01\0\0a\x16\x1B\x83b\x12u\0a\x16\xDDV[\x96\x95PPPPPPV[_a\x01\xB3\x83\x83\x01` \x01Q\x90V[_a\x01\xB6{\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\x83a\x16\xDDV[_a\x01\xB6\x82`Da\x16AV[_\x82\x82\x11\x15a\x16\xD3W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x02sV[a\x01\xB3\x82\x84a\x1A;V[_a\x01\xB3\x82\x84a\x1A(V[_\x82_\x03a\x16\xF7WP_a\x01\xB6V[a\x17\x01\x82\x84a\x1B\xAFV[\x90P\x81a\x17\x0E\x84\x83a\x1A(V[\x14a\x01\xB6W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x02sV[__`@\x83\x85\x03\x12\x15a\x17lW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x17\x8BW__\xFD[P5\x91\x90PV[__\x83`\x1F\x84\x01\x12a\x17\xA2W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17\xB9W__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x17\xD0W__\xFD[\x92P\x92\x90PV[____`@\x85\x87\x03\x12\x15a\x17\xEAW__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\0W__\xFD[a\x18\x0C\x87\x82\x88\x01a\x17\x92V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18+W__\xFD[a\x187\x87\x82\x88\x01a\x17\x92V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x18XW__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18uW__\xFD[a\x18\x81\x89\x82\x8A\x01a\x17\x92V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\xA0W__\xFD[a\x18\xAC\x89\x82\x8A\x01a\x17\x92V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x18\xD9W__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\xEFW__\xFD[a\x18\xFB\x89\x82\x8A\x01a\x17\x92V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x19\x1AW__\xFD[a\x19&\x89\x82\x8A\x01a\x17\x92V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x19EW__\xFD[a\x19Q\x89\x82\x8A\x01a\x17\x92V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[___``\x84\x86\x03\x12\x15a\x19uW__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\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[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x01\xB6Wa\x01\xB6a\x19\x8CV[\x80\x82\x01\x80\x82\x11\x15a\x01\xB6Wa\x01\xB6a\x19\x8CV[\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\x1A#Wa\x1A#a\x19\xE8V[P\x06\x90V[_\x82a\x1A6Wa\x1A6a\x19\xE8V[P\x04\x90V[\x81\x81\x03\x81\x81\x11\x15a\x01\xB6Wa\x01\xB6a\x19\x8CV[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x1AtW__\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[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x01\xB6Wa\x01\xB6a\x19\x8CV[`\x01\x81[`\x01\x84\x11\x15a\x1A\xFCW\x80\x85\x04\x81\x11\x15a\x1A\xE0Wa\x1A\xE0a\x19\x8CV[`\x01\x84\x16\x15a\x1A\xEEW\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x1A\xC5V[\x93P\x93\x91PPV[_\x82a\x1B\x12WP`\x01a\x01\xB6V[\x81a\x1B\x1EWP_a\x01\xB6V[\x81`\x01\x81\x14a\x1B4W`\x02\x81\x14a\x1B>Wa\x1BZV[`\x01\x91PPa\x01\xB6V[`\xFF\x84\x11\x15a\x1BOWa\x1BOa\x19\x8CV[PP`\x01\x82\x1Ba\x01\xB6V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x1B}WP\x81\x81\na\x01\xB6V[a\x1B\x89_\x19\x84\x84a\x1A\xC1V[\x80_\x19\x04\x82\x11\x15a\x1B\x9CWa\x1B\x9Ca\x19\x8CV[\x02\x93\x92PPPV[_a\x01\xB3\x83\x83a\x1B\x04V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x01\xB6Wa\x01\xB6a\x19\x8CV\xFE\xA2dipfsX\"\x12 >\xFE\xC4\xD8.\xBD\xB8\x7F\rf\xA3\x8Eq\x02fi!\xFA\x84\xD6#\xE9\xB3\x1DSyJ\xB72Y\xF5\x83dsolcC\0\x08\x1C\x003", + b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xCFW_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0}W\x80c\xB9\x85b\x1A\x11a\0XW\x80c\xB9\x85b\x1A\x14a\x01\x86W\x80c\xC5\x82B\xCD\x14a\x01\x99W\x80c\xE3\xD8\xD8\xD8\x14a\x01\xA1W__\xFD[\x80cp\xD5<\x18\x14a\x01CW\x80ct\xC3\xA3\xA9\x14a\x01`W\x80c\x7F\xA67\xFC\x14a\x01sW__\xFD[\x80c0\x01{;\x11a\0\xADW\x80c0\x01{;\x14a\0\xFAW\x80c`\xB5\xC3\x90\x14a\x01\rW\x80ce\xDAA\xB9\x14a\x01 W__\xFD[\x80c\x117d\xBE\x14a\0\xD3W\x80c\x19\x10\xD9s\x14a\0\xEAW\x80c+\x97\xBE$\x14a\0\xF2W[__\xFD[`\x05T[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[`\x01Ta\0\xD7V[`\x06Ta\0\xD7V[a\0\xD7a\x01\x086`\x04a\x17[V[a\x01\xA8V[a\0\xD7a\x01\x1B6`\x04a\x17{V[a\x01\xBCV[a\x013a\x01.6`\x04a\x17\xD7V[a\x01\xC6V[`@Q\x90\x15\x15\x81R` \x01a\0\xE1V[a\x01K`\x04\x81V[`@Qc\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\0\xE1V[a\x013a\x01n6`\x04a\x18CV[a\x03\x82V[a\x013a\x01\x816`\x04a\x18\xC4V[a\x04\xF7V[a\x013a\x01\x946`\x04a\x19cV[a\x06\xD6V[`\x02Ta\0\xD7V[_Ta\0\xD7V[_a\x01\xB3\x83\x83a\x06\xECV[\x90P[\x92\x91PPV[_a\x01\xB6\x82a\x07^V[_a\x02\x05\x83\x83\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\x08\x0C\x92PPPV[a\x02|W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`+`$\x82\x01R\x7FHeader array length must be divi`D\x82\x01R\x7Fsible by 80\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\x02\xBA\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\x08\"\x92PPPV[a\x03\x06W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7FAnchor must be 80 bytes\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[a\x03w\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\x91RPP`@\x80Q` `\x1F\x89\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x87\x81R\x92P\x87\x91P\x86\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x82\x90RP\x92Pa\x08)\x91PPV[\x90P[\x94\x93PPPPV[_a\x03\xC1\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\x91RPa\x08\"\x92PPPV[\x80\x15a\x04\x06WPa\x04\x06\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\x91RPa\x08\"\x92PPPV[a\x04xW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`.`$\x82\x01R\x7FBad args. Check header and array`D\x82\x01R\x7F byte lengths.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02sV[a\x04\xEC\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_\x92\x01\x91\x90\x91RPP`@\x80Q` `\x1F\x8B\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x89\x81R\x92P\x89\x91P\x88\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RP\x88\x92Pa\x0C\x16\x91PPV[\x97\x96PPPPPPPV[_a\x056\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\x91RPa\x08\"\x92PPPV[\x80\x15a\x05{WPa\x05{\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\x08\"\x92PPPV[\x80\x15a\x05\xC0WPa\x05\xC0\x83\x83\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\x08\x0C\x92PPPV[a\x062W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`.`$\x82\x01R\x7FBad args. Check header and array`D\x82\x01R\x7F byte lengths.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02sV[a\x04\xEC\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\x91RPP`@\x80Q` `\x1F\x8B\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x89\x81R\x92P\x89\x91P\x88\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RPP`@\x80Q` `\x1F\x8A\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x88\x81R\x92P\x88\x91P\x87\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RPa\x0E\xB3\x92PPPV[_a\x06\xE2\x84\x84\x84a\x11EV[\x90P[\x93\x92PPPV[_\x82\x81[\x83\x81\x10\x15a\x07\x10W_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x06\xF0V[P\x80a\x01\xB3W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[_\x80\x82\x81[a\x07o`\x04`\x01a\x19\xB9V[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x07\xC3W_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\x07\xA8W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x07\xBBV[a\x07\xB2\x81\x84a\x19\xD5V[\x95\x94PPPPPV[`\x01\x01a\x07cV[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[_`P\x82Qa\x08\x1B\x91\x90a\x1A\x15V[\x15\x92\x91PPV[Q`P\x14\x90V[__a\x084\x85a\x11\x86V[\x90P_a\x08@\x82a\x07^V[\x90P_a\x08L\x86a\x12^V[\x90P\x84\x80a\x08aWP\x80a\x08_\x88a\x12^V[\x14[a\x08\xD2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x02sV[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x0B\xD3Wa\x08\xED`P\x82a\x1A(V[a\x08\xF8\x90`\x01a\x19\xD5V[a\t\x02\x90\x87a\x19\xD5V[\x93Pa\t\x10\x8A\x82`Pa\x12iV[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\n\xE6W\x84a\nf\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\n\xB4W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\n\xCF`\x04\x85a\x1A\x15V[_\x03a\n\xE6W_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\n\xF1\x8B\x83a\x12\x8EV[\x14a\x0B>W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[\x86a\x0BI\x8B\x83a\x13'V[\x14a\x0B\xBCW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x02sV[\x82\x96P`P\x81a\x0B\xCC\x91\x90a\x19\xD5V[\x90Pa\x08\xDAV[P\x81a\x0B\xDE\x8Ba\x11\x86V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x0C\x8FW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02sV[_a\x0C\x99\x84a\x11\x86V[\x90P_a\x0C\xA5\x86a\x11\x86V[\x90P`\x01T\x81\x14a\x0C\xF8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x02sV[_\x82\x81R`\x03` R`@\x90 Ta\rRW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[a\r`\x87`\x01T\x84\x87a\x13?V[a\r\xD2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x02sV[\x81a\r\xDE\x88\x88\x88a\x13\xD9V[\x14a\x0EQW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02sV[`\x01\x82\x90U`\x02\x87\x90U_a\x0Ee\x86a\x15jV[\x90P`\x05T\x81\x14a\x0EvW`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x0E\xC6a\x0E\xC1\x86a\x11\x86V[a\x07^V[\x90P_a\x0E\xD5a\x0E\xC1\x86a\x11\x86V[\x90Pa\x0E\xE3a\x07\xE0\x82a\x1A\x15V[a\x07\xDF\x14a\x0FYW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x02sV[a\x0Fe\x82a\x07\xDFa\x19\xD5V[\x81\x14a\x0F\xD9W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x02sV[a\x0F\xE2\x85a\x15jV[a\x0F\xEB\x87a\x15jV[\x14a\x10^W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x02sV[_a\x10h\x85a\x12^V[\x90P_a\x10\x9Aa\x10w\x89a\x12^V[a\x10\x80\x8Aa\x15|V[c\xFF\xFF\xFF\xFF\x16a\x10\x8F\x8Aa\x15|V[c\xFF\xFF\xFF\xFF\x16a\x15\xAFV[\x90P\x81\x81\x83\x16\x14a\x10\xEDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02sV[_a\x10\xF7\x89a\x15jV[\x90P\x80`\x06T\x14\x15\x80\x15a\x11!WPa\x07\xE0a\x11\x14`\x01Ta\x07^V[a\x11\x1E\x91\x90a\x1A;V[\x84\x11[\x15a\x11,W`\x06\x81\x90U[a\x118\x88\x88`\x01a\x08)V[\x99\x98PPPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\x11{W\x85\x82\x03a\x11cW`\x01\x92PPPa\x06\xE5V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x11IV[P_\x95\x94PPPPPV[_`\x02\x80\x83`@Qa\x11\x98\x91\x90a\x1ANV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x11\xB3W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\xD6\x91\x90a\x1AdV[`@Q` \x01a\x11\xE8\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\x90\x82\x90Ra\x12 \x91a\x1ANV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x12;W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x1AdV[_a\x01\xB6\x82_a\x12\x8EV[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x12\xA5a\x12\x9E\x84`Ha\x19\xD5V[\x85\x90a\x16AV[`\xE8\x1C\x90P_\x84a\x12\xB7\x85`Ka\x19\xD5V[\x81Q\x81\x10a\x12\xC7Wa\x12\xC7a\x1A{V[\x01` \x01Q`\xF8\x1C\x90P_a\x12\xF9\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x13\x0C`\x03\x84a\x1A\xA8V[`\xFF\x16\x90Pa\x13\x1D\x81a\x01\0a\x1B\xA4V[a\x04\xEC\x90\x83a\x1B\xAFV[_a\x01\xB3a\x136\x83`\x04a\x19\xD5V[\x84\x01` \x01Q\x90V[_\x83\x85\x14\x80\x15a\x13NWP\x82\x85\x14[\x15a\x13[WP`\x01a\x03zV[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x13\xA3W\x89\x83\x14a\x13\x82W_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x13\x9BW_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x13aV[P\x82\x84\x03a\x13\xB7W_\x94PPPPPa\x03zV[\x80\x82\x14a\x13\xCAW_\x94PPPPPa\x03zV[P`\x01\x98\x97PPPPPPPPV[__a\x13\xE4\x85a\x07^V[\x90P_a\x13\xF3a\x0E\xC1\x86a\x11\x86V[\x90P_a\x14\x02a\x0E\xC1\x86a\x11\x86V[\x90P\x82\x82\x10\x15\x80\x15a\x14\x14WP\x82\x81\x10\x15[a\x14\x86W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02sV[_a\x14\x93a\x07\xE0\x85a\x1A\x15V[a\x14\x9F\x85a\x07\xE0a\x19\xD5V[a\x14\xA9\x91\x90a\x1A;V[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x14\xBBWP\x80[\x15a\x14\xD6Wa\x14\xC9\x89a\x11\x86V[\x96PPPPPPPa\x06\xE5V[\x81\x80\x15a\x14\xE1WP\x80\x15[\x15a\x14\xEFWa\x14\xC9\x88a\x11\x86V[\x81\x80\x15a\x14\xF9WP\x80[\x15a\x15\x1DW\x83\x85\x10\x15a\x15\x14Wa\x15\x0F\x88a\x11\x86V[a\x14\xC9V[a\x14\xC9\x89a\x11\x86V[a\x15&\x88a\x15jV[a\x152a\x07\xE0\x86a\x1A\x15V[a\x15<\x91\x90a\x1B\xAFV[a\x15E\x8Aa\x15jV[a\x15Qa\x07\xE0\x88a\x1A\x15V[a\x15[\x91\x90a\x1B\xAFV[\x10\x15a\x15\x14Wa\x14\xC9\x88a\x11\x86V[_a\x01\xB6a\x15w\x83a\x12^V[a\x16OV[_a\x01\xB6a\x15\x89\x83a\x16vV[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x15\xBB\x83\x85a\x16\x82V[\x90Pa\x15\xCBb\x12u\0`\x04a\x16\xDDV[\x81\x10\x15a\x15\xE3Wa\x15\xE0b\x12u\0`\x04a\x16\xDDV[\x90P[a\x15\xF1b\x12u\0`\x04a\x16\xE8V[\x81\x11\x15a\x16\tWa\x16\x06b\x12u\0`\x04a\x16\xE8V[\x90P[_a\x16!\x82a\x16\x1B\x88b\x01\0\0a\x16\xDDV[\x90a\x16\xE8V[\x90Pa\x167b\x01\0\0a\x16\x1B\x83b\x12u\0a\x16\xDDV[\x96\x95PPPPPPV[_a\x01\xB3\x83\x83\x01` \x01Q\x90V[_a\x01\xB6{\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\x83a\x16\xDDV[_a\x01\xB6\x82`Da\x16AV[_\x82\x82\x11\x15a\x16\xD3W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x02sV[a\x01\xB3\x82\x84a\x1A;V[_a\x01\xB3\x82\x84a\x1A(V[_\x82_\x03a\x16\xF7WP_a\x01\xB6V[a\x17\x01\x82\x84a\x1B\xAFV[\x90P\x81a\x17\x0E\x84\x83a\x1A(V[\x14a\x01\xB6W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x02sV[__`@\x83\x85\x03\x12\x15a\x17lW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x17\x8BW__\xFD[P5\x91\x90PV[__\x83`\x1F\x84\x01\x12a\x17\xA2W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17\xB9W__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x17\xD0W__\xFD[\x92P\x92\x90PV[____`@\x85\x87\x03\x12\x15a\x17\xEAW__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\0W__\xFD[a\x18\x0C\x87\x82\x88\x01a\x17\x92V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18+W__\xFD[a\x187\x87\x82\x88\x01a\x17\x92V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x18XW__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18uW__\xFD[a\x18\x81\x89\x82\x8A\x01a\x17\x92V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\xA0W__\xFD[a\x18\xAC\x89\x82\x8A\x01a\x17\x92V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x18\xD9W__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\xEFW__\xFD[a\x18\xFB\x89\x82\x8A\x01a\x17\x92V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x19\x1AW__\xFD[a\x19&\x89\x82\x8A\x01a\x17\x92V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x19EW__\xFD[a\x19Q\x89\x82\x8A\x01a\x17\x92V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[___``\x84\x86\x03\x12\x15a\x19uW__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\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[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x01\xB6Wa\x01\xB6a\x19\x8CV[\x80\x82\x01\x80\x82\x11\x15a\x01\xB6Wa\x01\xB6a\x19\x8CV[\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\x1A#Wa\x1A#a\x19\xE8V[P\x06\x90V[_\x82a\x1A6Wa\x1A6a\x19\xE8V[P\x04\x90V[\x81\x81\x03\x81\x81\x11\x15a\x01\xB6Wa\x01\xB6a\x19\x8CV[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x1AtW__\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[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x01\xB6Wa\x01\xB6a\x19\x8CV[`\x01\x81[`\x01\x84\x11\x15a\x1A\xFCW\x80\x85\x04\x81\x11\x15a\x1A\xE0Wa\x1A\xE0a\x19\x8CV[`\x01\x84\x16\x15a\x1A\xEEW\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x1A\xC5V[\x93P\x93\x91PPV[_\x82a\x1B\x12WP`\x01a\x01\xB6V[\x81a\x1B\x1EWP_a\x01\xB6V[\x81`\x01\x81\x14a\x1B4W`\x02\x81\x14a\x1B>Wa\x1BZV[`\x01\x91PPa\x01\xB6V[`\xFF\x84\x11\x15a\x1BOWa\x1BOa\x19\x8CV[PP`\x01\x82\x1Ba\x01\xB6V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x1B}WP\x81\x81\na\x01\xB6V[a\x1B\x89_\x19\x84\x84a\x1A\xC1V[\x80_\x19\x04\x82\x11\x15a\x1B\x9CWa\x1B\x9Ca\x19\x8CV[\x02\x93\x92PPPV[_a\x01\xB3\x83\x83a\x1B\x04V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x01\xB6Wa\x01\xB6a\x19\x8CV\xFE\xA2dipfsX\"\x12 \xC2\xB989`HD\xCC7\x9C\xB1\x04\xC6/d\xCA\x91\xFD\xF4&\x07@\xC2\x05\xE9'\xCB\x05\xD6<\xAC.dsolcC\0\x08\x1C\x003", ); #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] diff --git a/crates/bindings/src/fullrelaywithverify.rs b/crates/bindings/src/full_relay_with_verify.rs similarity index 82% rename from crates/bindings/src/fullrelaywithverify.rs rename to crates/bindings/src/full_relay_with_verify.rs index 343efc72c..76d3f30d8 100644 --- a/crates/bindings/src/fullrelaywithverify.rs +++ b/crates/bindings/src/full_relay_with_verify.rs @@ -396,22 +396,22 @@ pub mod FullRelayWithVerify { /// 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\x15a\0\x0FW__\xFD[P`@Qa'\r8\x03\x80a'\r\x839\x81\x01`@\x81\x90Ra\0.\x91a\x03%V[\x82\x82\x82a\0<\x83Q`P\x14\x90V[a\0\x81W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x11`$\x82\x01RpBad genesis block`x\x1B`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\0\x8B\x84a\x01`V[\x90Pb\xFF\xFF\xFF\x82\x16\x15a\x01\x06W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FPeriod start hash does not have `D\x82\x01R\x7Fwork. Hint: wrong byte order?\0\0\0`d\x82\x01R`\x84\x01a\0xV[_\x81\x81U`\x01\x82\x90U`\x02\x82\x90U\x81\x81R`\x04` R`@\x90 \x83\x90Ua\x01/a\x07\xE0\x84a\x03\xF8V[a\x019\x90\x84a\x04\x1FV[_\x83\x81R`\x04` R`@\x90 Ua\x01P\x84a\x02 V[`\x05UPa\x05\xB7\x95PPPPPPV[_`\x02\x80\x83`@Qa\x01r\x91\x90a\x042V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\x8DW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB0\x91\x90a\x04HV[`@Q` \x01a\x01\xC2\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x01\xDC\x91a\x042V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\xF7W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\x1A\x91\x90a\x04HV[\x92\x91PPV[_a\x02\x1Aa\x02-\x83a\x022V[a\x02=V[_a\x02\x1A\x82\x82a\x02MV[_a\x02\x1Aa\xFF\xFF`\xD0\x1B\x83a\x02\xF1V[_\x80a\x02da\x02]\x84`Ha\x04_V[\x85\x90a\x03\x03V[`\xE8\x1C\x90P_\x84a\x02v\x85`Ka\x04_V[\x81Q\x81\x10a\x02\x86Wa\x02\x86a\x04rV[\x01` \x01Q`\xF8\x1C\x90P_a\x02\xB8\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x02\xCB`\x03\x84a\x04\x86V[`\xFF\x16\x90Pa\x02\xDC\x81a\x01\0a\x05\x82V[a\x02\xE6\x90\x83a\x05\x8DV[\x97\x96PPPPPPPV[_a\x02\xFC\x82\x84a\x05\xA4V[\x93\x92PPPV[_a\x02\xFC\x83\x83\x01` \x01Q\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x037W__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03LW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03\\W__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03uWa\x03ua\x03\x11V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x03\xA3Wa\x03\xA3a\x03\x11V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x03\xBAW__\xFD[\x81` \x84\x01` \x83\x01^_` \x92\x82\x01\x83\x01R\x90\x86\x01Q`@\x90\x96\x01Q\x90\x97\x95\x96P\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x04\x06Wa\x04\x06a\x03\xE4V[P\x06\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x02\x1AWa\x02\x1Aa\x04\x0BV[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x04XW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02\x1AWa\x02\x1Aa\x04\x0BV[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x02\x1AWa\x02\x1Aa\x04\x0BV[`\x01\x81[`\x01\x84\x11\x15a\x04\xDAW\x80\x85\x04\x81\x11\x15a\x04\xBEWa\x04\xBEa\x04\x0BV[`\x01\x84\x16\x15a\x04\xCCW\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x04\xA3V[\x93P\x93\x91PPV[_\x82a\x04\xF0WP`\x01a\x02\x1AV[\x81a\x04\xFCWP_a\x02\x1AV[\x81`\x01\x81\x14a\x05\x12W`\x02\x81\x14a\x05\x1CWa\x058V[`\x01\x91PPa\x02\x1AV[`\xFF\x84\x11\x15a\x05-Wa\x05-a\x04\x0BV[PP`\x01\x82\x1Ba\x02\x1AV[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x05[WP\x81\x81\na\x02\x1AV[a\x05g_\x19\x84\x84a\x04\x9FV[\x80_\x19\x04\x82\x11\x15a\x05zWa\x05za\x04\x0BV[\x02\x93\x92PPPV[_a\x02\xFC\x83\x83a\x04\xE2V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x02\x1AWa\x02\x1Aa\x04\x0BV[_\x82a\x05\xB2Wa\x05\xB2a\x03\xE4V[P\x04\x90V[a!I\x80a\x05\xC4_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xE5W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\x88W\x80c\xB9\x85b\x1A\x11a\0cW\x80c\xB9\x85b\x1A\x14a\x01\xB1W\x80c\xC5\x82B\xCD\x14a\x01\xC4W\x80c\xE3\xD8\xD8\xD8\x14a\x01\xCCW\x80c\xE4q\xE7,\x14a\x01\xD3W__\xFD[\x80cp\xD5<\x18\x14a\x01nW\x80ct\xC3\xA3\xA9\x14a\x01\x8BW\x80c\x7F\xA67\xFC\x14a\x01\x9EW__\xFD[\x80c+\x97\xBE$\x11a\0\xC3W\x80c+\x97\xBE$\x14a\x01\x1DW\x80c0\x01{;\x14a\x01%W\x80c`\xB5\xC3\x90\x14a\x018W\x80ce\xDAA\xB9\x14a\x01KW__\xFD[\x80c\x05\xD0\x9Ap\x14a\0\xE9W\x80c\x117d\xBE\x14a\0\xFEW\x80c\x19\x10\xD9s\x14a\x01\x15W[__\xFD[a\0\xFCa\0\xF76`\x04a\x1C2V[a\x01\xE6V[\0[`\x05T[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[`\x01Ta\x01\x02V[`\x06Ta\x01\x02V[a\x01\x02a\x0136`\x04a\x1C\xC3V[a\x04\x1FV[a\x01\x02a\x01F6`\x04a\x1C\xE3V[a\x043V[a\x01^a\x01Y6`\x04a\x1C\xFAV[a\x04=V[`@Q\x90\x15\x15\x81R` \x01a\x01\x0CV[a\x01v`\x04\x81V[`@Qc\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\x01\x0CV[a\x01^a\x01\x996`\x04a\x1DfV[a\x05\xF4V[a\x01^a\x01\xAC6`\x04a\x1D\xE7V[a\x07iV[a\x01^a\x01\xBF6`\x04a\x1E\x86V[a\tHV[`\x02Ta\x01\x02V[_Ta\x01\x02V[a\0\xFCa\x01\xE16`\x04a\x1E\xAFV[a\t^V[a\x02$\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\x91RPa\n&\x92PPPV[a\x02uW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FBad header block\0\0\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[a\x02\xB3\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\n-\x92PPPV[a\x02\xFFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7FBad merkle array proof\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[a\x03~\x83a\x03A\x89\x89\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\nC\x92PPPV[\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\x91RP\x88\x92Pa\nO\x91PPV[a\x03\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FBad inclusion proof\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[_a\x04\t\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_\x92\x01\x91\x90\x91RPa\n\x81\x92PPPV[\x90Pa\x04\x15\x81\x83a\t^V[PPPPPPPPV[_a\x04*\x83\x83a\x0BYV[\x90P[\x92\x91PPV[_a\x04-\x82a\x0B\xCBV[_a\x04|\x83\x83\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\x0Cy\x92PPPV[a\x04\xEEW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`+`$\x82\x01R\x7FHeader array length must be divi`D\x82\x01R\x7Fsible by 80\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\x02lV[a\x05,\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\n&\x92PPPV[a\x05xW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7FAnchor must be 80 bytes\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[a\x05\xE9\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\x91RPP`@\x80Q` `\x1F\x89\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x87\x81R\x92P\x87\x91P\x86\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x82\x90RP\x92Pa\x0C\x88\x91PPV[\x90P[\x94\x93PPPPV[_a\x063\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\x91RPa\n&\x92PPPV[\x80\x15a\x06xWPa\x06x\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\x91RPa\n&\x92PPPV[a\x06\xEAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`.`$\x82\x01R\x7FBad args. Check header and array`D\x82\x01R\x7F byte lengths.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02lV[a\x07^\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_\x92\x01\x91\x90\x91RPP`@\x80Q` `\x1F\x8B\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x89\x81R\x92P\x89\x91P\x88\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RP\x88\x92Pa\x10u\x91PPV[\x97\x96PPPPPPPV[_a\x07\xA8\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\x91RPa\n&\x92PPPV[\x80\x15a\x07\xEDWPa\x07\xED\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\n&\x92PPPV[\x80\x15a\x082WPa\x082\x83\x83\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\x0Cy\x92PPPV[a\x08\xA4W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`.`$\x82\x01R\x7FBad args. Check header and array`D\x82\x01R\x7F byte lengths.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02lV[a\x07^\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\x91RPP`@\x80Q` `\x1F\x8B\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x89\x81R\x92P\x89\x91P\x88\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RPP`@\x80Q` `\x1F\x8A\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x88\x81R\x92P\x88\x91P\x87\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RPa\x13\x12\x92PPPV[_a\tT\x84\x84\x84a\x15\xA4V[\x90P[\x93\x92PPPV[_a\th`\x02T\x90V[\x90Pa\tw\x83\x82a\x08\0a\x15\xA4V[a\t\xC3W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FGCD does not confirm header\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[\x81`\xFF\x16a\t\xD0\x84a\x15\xE5V[`\xFF\x16\x10\x15a\n!W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient confirmations\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[PPPV[Q`P\x14\x90V[_` \x82Qa\n<\x91\x90a\x1F\x06V[\x15\x92\x91PPV[`D\x81\x01Q_\x90a\x04-V[_\x83\x85\x14\x80\x15a\n]WP\x81\x15[\x80\x15a\nhWP\x82Q\x15[\x15a\nuWP`\x01a\x05\xECV[a\x05\xE9\x85\x84\x86\x85a\x16\x04V[_`\x02\x80\x83`@Qa\n\x93\x91\x90a\x1F\x19V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\n\xAEW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xD1\x91\x90a\x1F/V[`@Q` \x01a\n\xE3\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\x90\x82\x90Ra\x0B\x1B\x91a\x1F\x19V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0B6W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04-\x91\x90a\x1F/V[_\x82\x81[\x83\x81\x10\x15a\x0B}W_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x0B]V[P\x80a\x04*W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[_\x80\x82\x81[a\x0B\xDC`\x04`\x01a\x1FsV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0C0W_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\x0C\x15W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0C(V[a\x0C\x1F\x81\x84a\x1F\x8FV[\x95\x94PPPPPV[`\x01\x01a\x0B\xD0V[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[_`P\x82Qa\n<\x91\x90a\x1F\x06V[__a\x0C\x93\x85a\n\x81V[\x90P_a\x0C\x9F\x82a\x0B\xCBV[\x90P_a\x0C\xAB\x86a\x16\xA9V[\x90P\x84\x80a\x0C\xC0WP\x80a\x0C\xBE\x88a\x16\xA9V[\x14[a\r1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x02lV[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x102Wa\rL`P\x82a\x1F\xA2V[a\rW\x90`\x01a\x1F\x8FV[a\ra\x90\x87a\x1F\x8FV[\x93Pa\ro\x8A\x82`Pa\x16\xB4V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x0FEW\x84a\x0E\xC5\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x0F\x13W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x0F.`\x04\x85a\x1F\x06V[_\x03a\x0FEW_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x0FP\x8B\x83a\x16\xD9V[\x14a\x0F\x9DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[\x86a\x0F\xA8\x8B\x83a\x17rV[\x14a\x10\x1BW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x02lV[\x82\x96P`P\x81a\x10+\x91\x90a\x1F\x8FV[\x90Pa\r9V[P\x81a\x10=\x8Ba\n\x81V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x10\xEEW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02lV[_a\x10\xF8\x84a\n\x81V[\x90P_a\x11\x04\x86a\n\x81V[\x90P`\x01T\x81\x14a\x11WW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x02lV[_\x82\x81R`\x03` R`@\x90 Ta\x11\xB1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[a\x11\xBF\x87`\x01T\x84\x87a\x17\x8AV[a\x121W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x02lV[\x81a\x12=\x88\x88\x88a\x18$V[\x14a\x12\xB0W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02lV[`\x01\x82\x90U`\x02\x87\x90U_a\x12\xC4\x86a\x19\xB5V[\x90P`\x05T\x81\x14a\x12\xD5W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x13%a\x13 \x86a\n\x81V[a\x0B\xCBV[\x90P_a\x134a\x13 \x86a\n\x81V[\x90Pa\x13Ba\x07\xE0\x82a\x1F\x06V[a\x07\xDF\x14a\x13\xB8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x02lV[a\x13\xC4\x82a\x07\xDFa\x1F\x8FV[\x81\x14a\x148W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x02lV[a\x14A\x85a\x19\xB5V[a\x14J\x87a\x19\xB5V[\x14a\x14\xBDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x02lV[_a\x14\xC7\x85a\x16\xA9V[\x90P_a\x14\xF9a\x14\xD6\x89a\x16\xA9V[a\x14\xDF\x8Aa\x19\xC7V[c\xFF\xFF\xFF\xFF\x16a\x14\xEE\x8Aa\x19\xC7V[c\xFF\xFF\xFF\xFF\x16a\x19\xFAV[\x90P\x81\x81\x83\x16\x14a\x15LW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[_a\x15V\x89a\x19\xB5V[\x90P\x80`\x06T\x14\x15\x80\x15a\x15\x80WPa\x07\xE0a\x15s`\x01Ta\x0B\xCBV[a\x15}\x91\x90a\x1F\xB5V[\x84\x11[\x15a\x15\x8BW`\x06\x81\x90U[a\x15\x97\x88\x88`\x01a\x0C\x88V[\x99\x98PPPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\x15\xDAW\x85\x82\x03a\x15\xC2W`\x01\x92PPPa\tWV[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x15\xA8V[P_\x95\x94PPPPPV[_a\x15\xEF\x82a\x0B\xCBV[a\x15\xFA`\x01Ta\x0B\xCBV[a\x04-\x91\x90a\x1F\xB5V[_` \x84Qa\x16\x13\x91\x90a\x1F\x06V[\x15a\x16\x1FWP_a\x05\xECV[\x83Q_\x03a\x16.WP_a\x05\xECV[\x81\x85_[\x86Q\x81\x10\x15a\x16\x9CWa\x16F`\x02\x84a\x1F\x06V[`\x01\x03a\x16jWa\x16ca\x16]\x88\x83\x01` \x01Q\x90V[\x83a\x1A\x8CV[\x91Pa\x16\x83V[a\x16\x80\x82a\x16{\x89\x84\x01` \x01Q\x90V[a\x1A\x8CV[\x91P[`\x01\x92\x90\x92\x1C\x91a\x16\x95` \x82a\x1F\x8FV[\x90Pa\x162V[P\x90\x93\x14\x95\x94PPPPPV[_a\x04-\x82_a\x16\xD9V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x16\xF0a\x16\xE9\x84`Ha\x1F\x8FV[\x85\x90a\x1A\x97V[`\xE8\x1C\x90P_\x84a\x17\x02\x85`Ka\x1F\x8FV[\x81Q\x81\x10a\x17\x12Wa\x17\x12a\x1F\xC8V[\x01` \x01Q`\xF8\x1C\x90P_a\x17D\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x17W`\x03\x84a\x1F\xF5V[`\xFF\x16\x90Pa\x17h\x81a\x01\0a \xF1V[a\x07^\x90\x83a \xFCV[_a\x04*a\x17\x81\x83`\x04a\x1F\x8FV[\x84\x01` \x01Q\x90V[_\x83\x85\x14\x80\x15a\x17\x99WP\x82\x85\x14[\x15a\x17\xA6WP`\x01a\x05\xECV[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x17\xEEW\x89\x83\x14a\x17\xCDW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x17\xE6W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x17\xACV[P\x82\x84\x03a\x18\x02W_\x94PPPPPa\x05\xECV[\x80\x82\x14a\x18\x15W_\x94PPPPPa\x05\xECV[P`\x01\x98\x97PPPPPPPPV[__a\x18/\x85a\x0B\xCBV[\x90P_a\x18>a\x13 \x86a\n\x81V[\x90P_a\x18Ma\x13 \x86a\n\x81V[\x90P\x82\x82\x10\x15\x80\x15a\x18_WP\x82\x81\x10\x15[a\x18\xD1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02lV[_a\x18\xDEa\x07\xE0\x85a\x1F\x06V[a\x18\xEA\x85a\x07\xE0a\x1F\x8FV[a\x18\xF4\x91\x90a\x1F\xB5V[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x19\x06WP\x80[\x15a\x19!Wa\x19\x14\x89a\n\x81V[\x96PPPPPPPa\tWV[\x81\x80\x15a\x19,WP\x80\x15[\x15a\x19:Wa\x19\x14\x88a\n\x81V[\x81\x80\x15a\x19DWP\x80[\x15a\x19hW\x83\x85\x10\x15a\x19_Wa\x19Z\x88a\n\x81V[a\x19\x14V[a\x19\x14\x89a\n\x81V[a\x19q\x88a\x19\xB5V[a\x19}a\x07\xE0\x86a\x1F\x06V[a\x19\x87\x91\x90a \xFCV[a\x19\x90\x8Aa\x19\xB5V[a\x19\x9Ca\x07\xE0\x88a\x1F\x06V[a\x19\xA6\x91\x90a \xFCV[\x10\x15a\x19_Wa\x19\x14\x88a\n\x81V[_a\x04-a\x19\xC2\x83a\x16\xA9V[a\x1A\xA5V[_a\x04-a\x19\xD4\x83a\x1A\xCCV[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1A\x06\x83\x85a\x1A\xD8V[\x90Pa\x1A\x16b\x12u\0`\x04a\x1B3V[\x81\x10\x15a\x1A.Wa\x1A+b\x12u\0`\x04a\x1B3V[\x90P[a\x1AV[\x81\x11\x15a\x1ATWa\x1AQb\x12u\0`\x04a\x1B>V[\x90P[_a\x1Al\x82a\x1Af\x88b\x01\0\0a\x1B3V[\x90a\x1B>V[\x90Pa\x1A\x82b\x01\0\0a\x1Af\x83b\x12u\0a\x1B3V[\x96\x95PPPPPPV[_a\x04*\x83\x83a\x1B\xB1V[_a\x04*\x83\x83\x01` \x01Q\x90V[_a\x04-{\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\x83a\x1B3V[_a\x04-\x82`Da\x1A\x97V[_\x82\x82\x11\x15a\x1B)W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x02lV[a\x04*\x82\x84a\x1F\xB5V[_a\x04*\x82\x84a\x1F\xA2V[_\x82_\x03a\x1BMWP_a\x04-V[a\x1BW\x82\x84a \xFCV[\x90P\x81a\x1Bd\x84\x83a\x1F\xA2V[\x14a\x04-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x02lV[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1B\xE8W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1B\xFFW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1C\x16W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1C-W__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1CHW__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1C^W__\xFD[a\x1Cj\x8A\x82\x8B\x01a\x1B\xD8V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1C\x89W__\xFD[a\x1C\x95\x8A\x82\x8B\x01a\x1B\xD8V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1C\xB5`\x80\x89\x01a\x1C\x1DV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[__`@\x83\x85\x03\x12\x15a\x1C\xD4W__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1C\xF3W__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1D\rW__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D#W__\xFD[a\x1D/\x87\x82\x88\x01a\x1B\xD8V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DNW__\xFD[a\x1DZ\x87\x82\x88\x01a\x1B\xD8V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1D{W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\x98W__\xFD[a\x1D\xA4\x89\x82\x8A\x01a\x1B\xD8V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xC3W__\xFD[a\x1D\xCF\x89\x82\x8A\x01a\x1B\xD8V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1D\xFCW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x12W__\xFD[a\x1E\x1E\x89\x82\x8A\x01a\x1B\xD8V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E=W__\xFD[a\x1EI\x89\x82\x8A\x01a\x1B\xD8V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1EhW__\xFD[a\x1Et\x89\x82\x8A\x01a\x1B\xD8V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[___``\x84\x86\x03\x12\x15a\x1E\x98W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x1E\xC0W__\xFD[\x825\x91Pa\x1E\xD0` \x84\x01a\x1C\x1DV[\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`\x12`\x04R`$_\xFD[_\x82a\x1F\x14Wa\x1F\x14a\x1E\xD9V[P\x06\x90V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x1F?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`\x11`\x04R`$_\xFD[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x04-Wa\x04-a\x1FFV[\x80\x82\x01\x80\x82\x11\x15a\x04-Wa\x04-a\x1FFV[_\x82a\x1F\xB0Wa\x1F\xB0a\x1E\xD9V[P\x04\x90V[\x81\x81\x03\x81\x81\x11\x15a\x04-Wa\x04-a\x1FFV[\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[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x04-Wa\x04-a\x1FFV[`\x01\x81[`\x01\x84\x11\x15a IW\x80\x85\x04\x81\x11\x15a -Wa -a\x1FFV[`\x01\x84\x16\x15a ;W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a \x12V[\x93P\x93\x91PPV[_\x82a _WP`\x01a\x04-V[\x81a kWP_a\x04-V[\x81`\x01\x81\x14a \x81W`\x02\x81\x14a \x8BWa \xA7V[`\x01\x91PPa\x04-V[`\xFF\x84\x11\x15a \x9CWa \x9Ca\x1FFV[PP`\x01\x82\x1Ba\x04-V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a \xCAWP\x81\x81\na\x04-V[a \xD6_\x19\x84\x84a \x0EV[\x80_\x19\x04\x82\x11\x15a \xE9Wa \xE9a\x1FFV[\x02\x93\x92PPPV[_a\x04*\x83\x83a QV[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x04-Wa\x04-a\x1FFV\xFE\xA2dipfsX\"\x12 -\xAE\x13\x86dS\xC0t\"\xFF\xF1\xAF\xA1\n\tl\xBB\xFA\xC6\xFBv\xC8\xB1\x11\xA2\x02}+\xDB\xEF\x8E\xE7dsolcC\0\x08\x1C\x003", + b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa&\x938\x03\x80a&\x93\x839\x81\x01`@\x81\x90Ra\0.\x91a\x02\xABV[\x82\x82\x82a\0<\x83Q`P\x14\x90V[a\0\x80W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x11`$\x82\x01RpBad genesis block`x\x1B`D\x82\x01R`d\x01`@Q\x80\x91\x03\x90\xFD[_a\0\x8A\x84a\0\xE6V[_\x81\x81U`\x01\x82\x90U`\x02\x82\x90U\x81\x81R`\x04` R`@\x90 \x84\x90U\x90Pa\0\xB5a\x07\xE0\x84a\x03~V[a\0\xBF\x90\x84a\x03\xA5V[_\x83\x81R`\x04` R`@\x90 Ua\0\xD6\x84a\x01\xA6V[`\x05UPa\x05=\x95PPPPPPV[_`\x02\x80\x83`@Qa\0\xF8\x91\x90a\x03\xB8V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\x13W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x016\x91\x90a\x03\xCEV[`@Q` \x01a\x01H\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x01b\x91a\x03\xB8V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01}W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xA0\x91\x90a\x03\xCEV[\x92\x91PPV[_a\x01\xA0a\x01\xB3\x83a\x01\xB8V[a\x01\xC3V[_a\x01\xA0\x82\x82a\x01\xD3V[_a\x01\xA0a\xFF\xFF`\xD0\x1B\x83a\x02wV[_\x80a\x01\xEAa\x01\xE3\x84`Ha\x03\xE5V[\x85\x90a\x02\x89V[`\xE8\x1C\x90P_\x84a\x01\xFC\x85`Ka\x03\xE5V[\x81Q\x81\x10a\x02\x0CWa\x02\x0Ca\x03\xF8V[\x01` \x01Q`\xF8\x1C\x90P_a\x02>\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x02Q`\x03\x84a\x04\x0CV[`\xFF\x16\x90Pa\x02b\x81a\x01\0a\x05\x08V[a\x02l\x90\x83a\x05\x13V[\x97\x96PPPPPPPV[_a\x02\x82\x82\x84a\x05*V[\x93\x92PPPV[_a\x02\x82\x83\x83\x01` \x01Q\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x02\xBDW__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x02\xD2W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x02\xE2W__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x02\xFBWa\x02\xFBa\x02\x97V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x03)Wa\x03)a\x02\x97V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x03@W__\xFD[\x81` \x84\x01` \x83\x01^_` \x92\x82\x01\x83\x01R\x90\x86\x01Q`@\x90\x96\x01Q\x90\x97\x95\x96P\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x03\x8CWa\x03\x8Ca\x03jV[P\x06\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x01\xA0Wa\x01\xA0a\x03\x91V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x03\xDEW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x01\xA0Wa\x01\xA0a\x03\x91V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x01\xA0Wa\x01\xA0a\x03\x91V[`\x01\x81[`\x01\x84\x11\x15a\x04`W\x80\x85\x04\x81\x11\x15a\x04DWa\x04Da\x03\x91V[`\x01\x84\x16\x15a\x04RW\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x04)V[\x93P\x93\x91PPV[_\x82a\x04vWP`\x01a\x01\xA0V[\x81a\x04\x82WP_a\x01\xA0V[\x81`\x01\x81\x14a\x04\x98W`\x02\x81\x14a\x04\xA2Wa\x04\xBEV[`\x01\x91PPa\x01\xA0V[`\xFF\x84\x11\x15a\x04\xB3Wa\x04\xB3a\x03\x91V[PP`\x01\x82\x1Ba\x01\xA0V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x04\xE1WP\x81\x81\na\x01\xA0V[a\x04\xED_\x19\x84\x84a\x04%V[\x80_\x19\x04\x82\x11\x15a\x05\0Wa\x05\0a\x03\x91V[\x02\x93\x92PPPV[_a\x02\x82\x83\x83a\x04hV[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x01\xA0Wa\x01\xA0a\x03\x91V[_\x82a\x058Wa\x058a\x03jV[P\x04\x90V[a!I\x80a\x05J_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xE5W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\x88W\x80c\xB9\x85b\x1A\x11a\0cW\x80c\xB9\x85b\x1A\x14a\x01\xB1W\x80c\xC5\x82B\xCD\x14a\x01\xC4W\x80c\xE3\xD8\xD8\xD8\x14a\x01\xCCW\x80c\xE4q\xE7,\x14a\x01\xD3W__\xFD[\x80cp\xD5<\x18\x14a\x01nW\x80ct\xC3\xA3\xA9\x14a\x01\x8BW\x80c\x7F\xA67\xFC\x14a\x01\x9EW__\xFD[\x80c+\x97\xBE$\x11a\0\xC3W\x80c+\x97\xBE$\x14a\x01\x1DW\x80c0\x01{;\x14a\x01%W\x80c`\xB5\xC3\x90\x14a\x018W\x80ce\xDAA\xB9\x14a\x01KW__\xFD[\x80c\x05\xD0\x9Ap\x14a\0\xE9W\x80c\x117d\xBE\x14a\0\xFEW\x80c\x19\x10\xD9s\x14a\x01\x15W[__\xFD[a\0\xFCa\0\xF76`\x04a\x1C2V[a\x01\xE6V[\0[`\x05T[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[`\x01Ta\x01\x02V[`\x06Ta\x01\x02V[a\x01\x02a\x0136`\x04a\x1C\xC3V[a\x04\x1FV[a\x01\x02a\x01F6`\x04a\x1C\xE3V[a\x043V[a\x01^a\x01Y6`\x04a\x1C\xFAV[a\x04=V[`@Q\x90\x15\x15\x81R` \x01a\x01\x0CV[a\x01v`\x04\x81V[`@Qc\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\x01\x0CV[a\x01^a\x01\x996`\x04a\x1DfV[a\x05\xF4V[a\x01^a\x01\xAC6`\x04a\x1D\xE7V[a\x07iV[a\x01^a\x01\xBF6`\x04a\x1E\x86V[a\tHV[`\x02Ta\x01\x02V[_Ta\x01\x02V[a\0\xFCa\x01\xE16`\x04a\x1E\xAFV[a\t^V[a\x02$\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\x91RPa\n&\x92PPPV[a\x02uW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FBad header block\0\0\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[a\x02\xB3\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\n-\x92PPPV[a\x02\xFFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7FBad merkle array proof\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[a\x03~\x83a\x03A\x89\x89\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\nC\x92PPPV[\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\x91RP\x88\x92Pa\nO\x91PPV[a\x03\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FBad inclusion proof\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[_a\x04\t\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_\x92\x01\x91\x90\x91RPa\n\x81\x92PPPV[\x90Pa\x04\x15\x81\x83a\t^V[PPPPPPPPV[_a\x04*\x83\x83a\x0BYV[\x90P[\x92\x91PPV[_a\x04-\x82a\x0B\xCBV[_a\x04|\x83\x83\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\x0Cy\x92PPPV[a\x04\xEEW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`+`$\x82\x01R\x7FHeader array length must be divi`D\x82\x01R\x7Fsible by 80\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\x02lV[a\x05,\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\n&\x92PPPV[a\x05xW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7FAnchor must be 80 bytes\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[a\x05\xE9\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\x91RPP`@\x80Q` `\x1F\x89\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x87\x81R\x92P\x87\x91P\x86\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x82\x90RP\x92Pa\x0C\x88\x91PPV[\x90P[\x94\x93PPPPV[_a\x063\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\x91RPa\n&\x92PPPV[\x80\x15a\x06xWPa\x06x\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\x91RPa\n&\x92PPPV[a\x06\xEAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`.`$\x82\x01R\x7FBad args. Check header and array`D\x82\x01R\x7F byte lengths.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02lV[a\x07^\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_\x92\x01\x91\x90\x91RPP`@\x80Q` `\x1F\x8B\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x89\x81R\x92P\x89\x91P\x88\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RP\x88\x92Pa\x10u\x91PPV[\x97\x96PPPPPPPV[_a\x07\xA8\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\x91RPa\n&\x92PPPV[\x80\x15a\x07\xEDWPa\x07\xED\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\n&\x92PPPV[\x80\x15a\x082WPa\x082\x83\x83\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\x0Cy\x92PPPV[a\x08\xA4W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`.`$\x82\x01R\x7FBad args. Check header and array`D\x82\x01R\x7F byte lengths.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02lV[a\x07^\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\x91RPP`@\x80Q` `\x1F\x8B\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x89\x81R\x92P\x89\x91P\x88\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RPP`@\x80Q` `\x1F\x8A\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x88\x81R\x92P\x88\x91P\x87\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RPa\x13\x12\x92PPPV[_a\tT\x84\x84\x84a\x15\xA4V[\x90P[\x93\x92PPPV[_a\th`\x02T\x90V[\x90Pa\tw\x83\x82a\x08\0a\x15\xA4V[a\t\xC3W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FGCD does not confirm header\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[\x81`\xFF\x16a\t\xD0\x84a\x15\xE5V[`\xFF\x16\x10\x15a\n!W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient confirmations\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[PPPV[Q`P\x14\x90V[_` \x82Qa\n<\x91\x90a\x1F\x06V[\x15\x92\x91PPV[`D\x81\x01Q_\x90a\x04-V[_\x83\x85\x14\x80\x15a\n]WP\x81\x15[\x80\x15a\nhWP\x82Q\x15[\x15a\nuWP`\x01a\x05\xECV[a\x05\xE9\x85\x84\x86\x85a\x16\x04V[_`\x02\x80\x83`@Qa\n\x93\x91\x90a\x1F\x19V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\n\xAEW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xD1\x91\x90a\x1F/V[`@Q` \x01a\n\xE3\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\x90\x82\x90Ra\x0B\x1B\x91a\x1F\x19V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0B6W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04-\x91\x90a\x1F/V[_\x82\x81[\x83\x81\x10\x15a\x0B}W_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x0B]V[P\x80a\x04*W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[_\x80\x82\x81[a\x0B\xDC`\x04`\x01a\x1FsV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0C0W_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\x0C\x15W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0C(V[a\x0C\x1F\x81\x84a\x1F\x8FV[\x95\x94PPPPPV[`\x01\x01a\x0B\xD0V[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[_`P\x82Qa\n<\x91\x90a\x1F\x06V[__a\x0C\x93\x85a\n\x81V[\x90P_a\x0C\x9F\x82a\x0B\xCBV[\x90P_a\x0C\xAB\x86a\x16\xA9V[\x90P\x84\x80a\x0C\xC0WP\x80a\x0C\xBE\x88a\x16\xA9V[\x14[a\r1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x02lV[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x102Wa\rL`P\x82a\x1F\xA2V[a\rW\x90`\x01a\x1F\x8FV[a\ra\x90\x87a\x1F\x8FV[\x93Pa\ro\x8A\x82`Pa\x16\xB4V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x0FEW\x84a\x0E\xC5\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x0F\x13W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x0F.`\x04\x85a\x1F\x06V[_\x03a\x0FEW_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x0FP\x8B\x83a\x16\xD9V[\x14a\x0F\x9DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[\x86a\x0F\xA8\x8B\x83a\x17rV[\x14a\x10\x1BW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x02lV[\x82\x96P`P\x81a\x10+\x91\x90a\x1F\x8FV[\x90Pa\r9V[P\x81a\x10=\x8Ba\n\x81V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x10\xEEW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02lV[_a\x10\xF8\x84a\n\x81V[\x90P_a\x11\x04\x86a\n\x81V[\x90P`\x01T\x81\x14a\x11WW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x02lV[_\x82\x81R`\x03` R`@\x90 Ta\x11\xB1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[a\x11\xBF\x87`\x01T\x84\x87a\x17\x8AV[a\x121W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x02lV[\x81a\x12=\x88\x88\x88a\x18$V[\x14a\x12\xB0W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02lV[`\x01\x82\x90U`\x02\x87\x90U_a\x12\xC4\x86a\x19\xB5V[\x90P`\x05T\x81\x14a\x12\xD5W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x13%a\x13 \x86a\n\x81V[a\x0B\xCBV[\x90P_a\x134a\x13 \x86a\n\x81V[\x90Pa\x13Ba\x07\xE0\x82a\x1F\x06V[a\x07\xDF\x14a\x13\xB8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x02lV[a\x13\xC4\x82a\x07\xDFa\x1F\x8FV[\x81\x14a\x148W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x02lV[a\x14A\x85a\x19\xB5V[a\x14J\x87a\x19\xB5V[\x14a\x14\xBDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x02lV[_a\x14\xC7\x85a\x16\xA9V[\x90P_a\x14\xF9a\x14\xD6\x89a\x16\xA9V[a\x14\xDF\x8Aa\x19\xC7V[c\xFF\xFF\xFF\xFF\x16a\x14\xEE\x8Aa\x19\xC7V[c\xFF\xFF\xFF\xFF\x16a\x19\xFAV[\x90P\x81\x81\x83\x16\x14a\x15LW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[_a\x15V\x89a\x19\xB5V[\x90P\x80`\x06T\x14\x15\x80\x15a\x15\x80WPa\x07\xE0a\x15s`\x01Ta\x0B\xCBV[a\x15}\x91\x90a\x1F\xB5V[\x84\x11[\x15a\x15\x8BW`\x06\x81\x90U[a\x15\x97\x88\x88`\x01a\x0C\x88V[\x99\x98PPPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\x15\xDAW\x85\x82\x03a\x15\xC2W`\x01\x92PPPa\tWV[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x15\xA8V[P_\x95\x94PPPPPV[_a\x15\xEF\x82a\x0B\xCBV[a\x15\xFA`\x01Ta\x0B\xCBV[a\x04-\x91\x90a\x1F\xB5V[_` \x84Qa\x16\x13\x91\x90a\x1F\x06V[\x15a\x16\x1FWP_a\x05\xECV[\x83Q_\x03a\x16.WP_a\x05\xECV[\x81\x85_[\x86Q\x81\x10\x15a\x16\x9CWa\x16F`\x02\x84a\x1F\x06V[`\x01\x03a\x16jWa\x16ca\x16]\x88\x83\x01` \x01Q\x90V[\x83a\x1A\x8CV[\x91Pa\x16\x83V[a\x16\x80\x82a\x16{\x89\x84\x01` \x01Q\x90V[a\x1A\x8CV[\x91P[`\x01\x92\x90\x92\x1C\x91a\x16\x95` \x82a\x1F\x8FV[\x90Pa\x162V[P\x90\x93\x14\x95\x94PPPPPV[_a\x04-\x82_a\x16\xD9V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x16\xF0a\x16\xE9\x84`Ha\x1F\x8FV[\x85\x90a\x1A\x97V[`\xE8\x1C\x90P_\x84a\x17\x02\x85`Ka\x1F\x8FV[\x81Q\x81\x10a\x17\x12Wa\x17\x12a\x1F\xC8V[\x01` \x01Q`\xF8\x1C\x90P_a\x17D\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x17W`\x03\x84a\x1F\xF5V[`\xFF\x16\x90Pa\x17h\x81a\x01\0a \xF1V[a\x07^\x90\x83a \xFCV[_a\x04*a\x17\x81\x83`\x04a\x1F\x8FV[\x84\x01` \x01Q\x90V[_\x83\x85\x14\x80\x15a\x17\x99WP\x82\x85\x14[\x15a\x17\xA6WP`\x01a\x05\xECV[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x17\xEEW\x89\x83\x14a\x17\xCDW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x17\xE6W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x17\xACV[P\x82\x84\x03a\x18\x02W_\x94PPPPPa\x05\xECV[\x80\x82\x14a\x18\x15W_\x94PPPPPa\x05\xECV[P`\x01\x98\x97PPPPPPPPV[__a\x18/\x85a\x0B\xCBV[\x90P_a\x18>a\x13 \x86a\n\x81V[\x90P_a\x18Ma\x13 \x86a\n\x81V[\x90P\x82\x82\x10\x15\x80\x15a\x18_WP\x82\x81\x10\x15[a\x18\xD1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02lV[_a\x18\xDEa\x07\xE0\x85a\x1F\x06V[a\x18\xEA\x85a\x07\xE0a\x1F\x8FV[a\x18\xF4\x91\x90a\x1F\xB5V[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x19\x06WP\x80[\x15a\x19!Wa\x19\x14\x89a\n\x81V[\x96PPPPPPPa\tWV[\x81\x80\x15a\x19,WP\x80\x15[\x15a\x19:Wa\x19\x14\x88a\n\x81V[\x81\x80\x15a\x19DWP\x80[\x15a\x19hW\x83\x85\x10\x15a\x19_Wa\x19Z\x88a\n\x81V[a\x19\x14V[a\x19\x14\x89a\n\x81V[a\x19q\x88a\x19\xB5V[a\x19}a\x07\xE0\x86a\x1F\x06V[a\x19\x87\x91\x90a \xFCV[a\x19\x90\x8Aa\x19\xB5V[a\x19\x9Ca\x07\xE0\x88a\x1F\x06V[a\x19\xA6\x91\x90a \xFCV[\x10\x15a\x19_Wa\x19\x14\x88a\n\x81V[_a\x04-a\x19\xC2\x83a\x16\xA9V[a\x1A\xA5V[_a\x04-a\x19\xD4\x83a\x1A\xCCV[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1A\x06\x83\x85a\x1A\xD8V[\x90Pa\x1A\x16b\x12u\0`\x04a\x1B3V[\x81\x10\x15a\x1A.Wa\x1A+b\x12u\0`\x04a\x1B3V[\x90P[a\x1AV[\x81\x11\x15a\x1ATWa\x1AQb\x12u\0`\x04a\x1B>V[\x90P[_a\x1Al\x82a\x1Af\x88b\x01\0\0a\x1B3V[\x90a\x1B>V[\x90Pa\x1A\x82b\x01\0\0a\x1Af\x83b\x12u\0a\x1B3V[\x96\x95PPPPPPV[_a\x04*\x83\x83a\x1B\xB1V[_a\x04*\x83\x83\x01` \x01Q\x90V[_a\x04-{\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\x83a\x1B3V[_a\x04-\x82`Da\x1A\x97V[_\x82\x82\x11\x15a\x1B)W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x02lV[a\x04*\x82\x84a\x1F\xB5V[_a\x04*\x82\x84a\x1F\xA2V[_\x82_\x03a\x1BMWP_a\x04-V[a\x1BW\x82\x84a \xFCV[\x90P\x81a\x1Bd\x84\x83a\x1F\xA2V[\x14a\x04-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x02lV[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1B\xE8W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1B\xFFW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1C\x16W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1C-W__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1CHW__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1C^W__\xFD[a\x1Cj\x8A\x82\x8B\x01a\x1B\xD8V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1C\x89W__\xFD[a\x1C\x95\x8A\x82\x8B\x01a\x1B\xD8V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1C\xB5`\x80\x89\x01a\x1C\x1DV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[__`@\x83\x85\x03\x12\x15a\x1C\xD4W__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1C\xF3W__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1D\rW__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D#W__\xFD[a\x1D/\x87\x82\x88\x01a\x1B\xD8V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DNW__\xFD[a\x1DZ\x87\x82\x88\x01a\x1B\xD8V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1D{W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\x98W__\xFD[a\x1D\xA4\x89\x82\x8A\x01a\x1B\xD8V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xC3W__\xFD[a\x1D\xCF\x89\x82\x8A\x01a\x1B\xD8V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1D\xFCW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x12W__\xFD[a\x1E\x1E\x89\x82\x8A\x01a\x1B\xD8V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E=W__\xFD[a\x1EI\x89\x82\x8A\x01a\x1B\xD8V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1EhW__\xFD[a\x1Et\x89\x82\x8A\x01a\x1B\xD8V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[___``\x84\x86\x03\x12\x15a\x1E\x98W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x1E\xC0W__\xFD[\x825\x91Pa\x1E\xD0` \x84\x01a\x1C\x1DV[\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`\x12`\x04R`$_\xFD[_\x82a\x1F\x14Wa\x1F\x14a\x1E\xD9V[P\x06\x90V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x1F?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`\x11`\x04R`$_\xFD[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x04-Wa\x04-a\x1FFV[\x80\x82\x01\x80\x82\x11\x15a\x04-Wa\x04-a\x1FFV[_\x82a\x1F\xB0Wa\x1F\xB0a\x1E\xD9V[P\x04\x90V[\x81\x81\x03\x81\x81\x11\x15a\x04-Wa\x04-a\x1FFV[\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[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x04-Wa\x04-a\x1FFV[`\x01\x81[`\x01\x84\x11\x15a IW\x80\x85\x04\x81\x11\x15a -Wa -a\x1FFV[`\x01\x84\x16\x15a ;W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a \x12V[\x93P\x93\x91PPV[_\x82a _WP`\x01a\x04-V[\x81a kWP_a\x04-V[\x81`\x01\x81\x14a \x81W`\x02\x81\x14a \x8BWa \xA7V[`\x01\x91PPa\x04-V[`\xFF\x84\x11\x15a \x9CWa \x9Ca\x1FFV[PP`\x01\x82\x1Ba\x04-V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a \xCAWP\x81\x81\na\x04-V[a \xD6_\x19\x84\x84a \x0EV[\x80_\x19\x04\x82\x11\x15a \xE9Wa \xE9a\x1FFV[\x02\x93\x92PPPV[_a\x04*\x83\x83a QV[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x04-Wa\x04-a\x1FFV\xFE\xA2dipfsX\"\x12 \\r\xD1\xBCS+\xF3\xDF&Q\xF6\xC4i\x15\x8E\xECS\xF0\x10,\xEF\xB1\x01\x83\x9AK\xF2r\x84\xA3V\xC6dsolcC\0\x08\x1C\x003", ); /// 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\xE5W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\x88W\x80c\xB9\x85b\x1A\x11a\0cW\x80c\xB9\x85b\x1A\x14a\x01\xB1W\x80c\xC5\x82B\xCD\x14a\x01\xC4W\x80c\xE3\xD8\xD8\xD8\x14a\x01\xCCW\x80c\xE4q\xE7,\x14a\x01\xD3W__\xFD[\x80cp\xD5<\x18\x14a\x01nW\x80ct\xC3\xA3\xA9\x14a\x01\x8BW\x80c\x7F\xA67\xFC\x14a\x01\x9EW__\xFD[\x80c+\x97\xBE$\x11a\0\xC3W\x80c+\x97\xBE$\x14a\x01\x1DW\x80c0\x01{;\x14a\x01%W\x80c`\xB5\xC3\x90\x14a\x018W\x80ce\xDAA\xB9\x14a\x01KW__\xFD[\x80c\x05\xD0\x9Ap\x14a\0\xE9W\x80c\x117d\xBE\x14a\0\xFEW\x80c\x19\x10\xD9s\x14a\x01\x15W[__\xFD[a\0\xFCa\0\xF76`\x04a\x1C2V[a\x01\xE6V[\0[`\x05T[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[`\x01Ta\x01\x02V[`\x06Ta\x01\x02V[a\x01\x02a\x0136`\x04a\x1C\xC3V[a\x04\x1FV[a\x01\x02a\x01F6`\x04a\x1C\xE3V[a\x043V[a\x01^a\x01Y6`\x04a\x1C\xFAV[a\x04=V[`@Q\x90\x15\x15\x81R` \x01a\x01\x0CV[a\x01v`\x04\x81V[`@Qc\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\x01\x0CV[a\x01^a\x01\x996`\x04a\x1DfV[a\x05\xF4V[a\x01^a\x01\xAC6`\x04a\x1D\xE7V[a\x07iV[a\x01^a\x01\xBF6`\x04a\x1E\x86V[a\tHV[`\x02Ta\x01\x02V[_Ta\x01\x02V[a\0\xFCa\x01\xE16`\x04a\x1E\xAFV[a\t^V[a\x02$\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\x91RPa\n&\x92PPPV[a\x02uW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FBad header block\0\0\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[a\x02\xB3\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\n-\x92PPPV[a\x02\xFFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7FBad merkle array proof\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[a\x03~\x83a\x03A\x89\x89\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\nC\x92PPPV[\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\x91RP\x88\x92Pa\nO\x91PPV[a\x03\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FBad inclusion proof\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[_a\x04\t\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_\x92\x01\x91\x90\x91RPa\n\x81\x92PPPV[\x90Pa\x04\x15\x81\x83a\t^V[PPPPPPPPV[_a\x04*\x83\x83a\x0BYV[\x90P[\x92\x91PPV[_a\x04-\x82a\x0B\xCBV[_a\x04|\x83\x83\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\x0Cy\x92PPPV[a\x04\xEEW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`+`$\x82\x01R\x7FHeader array length must be divi`D\x82\x01R\x7Fsible by 80\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\x02lV[a\x05,\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\n&\x92PPPV[a\x05xW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7FAnchor must be 80 bytes\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[a\x05\xE9\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\x91RPP`@\x80Q` `\x1F\x89\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x87\x81R\x92P\x87\x91P\x86\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x82\x90RP\x92Pa\x0C\x88\x91PPV[\x90P[\x94\x93PPPPV[_a\x063\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\x91RPa\n&\x92PPPV[\x80\x15a\x06xWPa\x06x\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\x91RPa\n&\x92PPPV[a\x06\xEAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`.`$\x82\x01R\x7FBad args. Check header and array`D\x82\x01R\x7F byte lengths.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02lV[a\x07^\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_\x92\x01\x91\x90\x91RPP`@\x80Q` `\x1F\x8B\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x89\x81R\x92P\x89\x91P\x88\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RP\x88\x92Pa\x10u\x91PPV[\x97\x96PPPPPPPV[_a\x07\xA8\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\x91RPa\n&\x92PPPV[\x80\x15a\x07\xEDWPa\x07\xED\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\n&\x92PPPV[\x80\x15a\x082WPa\x082\x83\x83\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\x0Cy\x92PPPV[a\x08\xA4W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`.`$\x82\x01R\x7FBad args. Check header and array`D\x82\x01R\x7F byte lengths.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02lV[a\x07^\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\x91RPP`@\x80Q` `\x1F\x8B\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x89\x81R\x92P\x89\x91P\x88\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RPP`@\x80Q` `\x1F\x8A\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x88\x81R\x92P\x88\x91P\x87\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RPa\x13\x12\x92PPPV[_a\tT\x84\x84\x84a\x15\xA4V[\x90P[\x93\x92PPPV[_a\th`\x02T\x90V[\x90Pa\tw\x83\x82a\x08\0a\x15\xA4V[a\t\xC3W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FGCD does not confirm header\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[\x81`\xFF\x16a\t\xD0\x84a\x15\xE5V[`\xFF\x16\x10\x15a\n!W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient confirmations\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[PPPV[Q`P\x14\x90V[_` \x82Qa\n<\x91\x90a\x1F\x06V[\x15\x92\x91PPV[`D\x81\x01Q_\x90a\x04-V[_\x83\x85\x14\x80\x15a\n]WP\x81\x15[\x80\x15a\nhWP\x82Q\x15[\x15a\nuWP`\x01a\x05\xECV[a\x05\xE9\x85\x84\x86\x85a\x16\x04V[_`\x02\x80\x83`@Qa\n\x93\x91\x90a\x1F\x19V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\n\xAEW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xD1\x91\x90a\x1F/V[`@Q` \x01a\n\xE3\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\x90\x82\x90Ra\x0B\x1B\x91a\x1F\x19V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0B6W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04-\x91\x90a\x1F/V[_\x82\x81[\x83\x81\x10\x15a\x0B}W_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x0B]V[P\x80a\x04*W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[_\x80\x82\x81[a\x0B\xDC`\x04`\x01a\x1FsV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0C0W_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\x0C\x15W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0C(V[a\x0C\x1F\x81\x84a\x1F\x8FV[\x95\x94PPPPPV[`\x01\x01a\x0B\xD0V[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[_`P\x82Qa\n<\x91\x90a\x1F\x06V[__a\x0C\x93\x85a\n\x81V[\x90P_a\x0C\x9F\x82a\x0B\xCBV[\x90P_a\x0C\xAB\x86a\x16\xA9V[\x90P\x84\x80a\x0C\xC0WP\x80a\x0C\xBE\x88a\x16\xA9V[\x14[a\r1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x02lV[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x102Wa\rL`P\x82a\x1F\xA2V[a\rW\x90`\x01a\x1F\x8FV[a\ra\x90\x87a\x1F\x8FV[\x93Pa\ro\x8A\x82`Pa\x16\xB4V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x0FEW\x84a\x0E\xC5\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x0F\x13W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x0F.`\x04\x85a\x1F\x06V[_\x03a\x0FEW_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x0FP\x8B\x83a\x16\xD9V[\x14a\x0F\x9DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[\x86a\x0F\xA8\x8B\x83a\x17rV[\x14a\x10\x1BW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x02lV[\x82\x96P`P\x81a\x10+\x91\x90a\x1F\x8FV[\x90Pa\r9V[P\x81a\x10=\x8Ba\n\x81V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x10\xEEW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02lV[_a\x10\xF8\x84a\n\x81V[\x90P_a\x11\x04\x86a\n\x81V[\x90P`\x01T\x81\x14a\x11WW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x02lV[_\x82\x81R`\x03` R`@\x90 Ta\x11\xB1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[a\x11\xBF\x87`\x01T\x84\x87a\x17\x8AV[a\x121W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x02lV[\x81a\x12=\x88\x88\x88a\x18$V[\x14a\x12\xB0W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02lV[`\x01\x82\x90U`\x02\x87\x90U_a\x12\xC4\x86a\x19\xB5V[\x90P`\x05T\x81\x14a\x12\xD5W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x13%a\x13 \x86a\n\x81V[a\x0B\xCBV[\x90P_a\x134a\x13 \x86a\n\x81V[\x90Pa\x13Ba\x07\xE0\x82a\x1F\x06V[a\x07\xDF\x14a\x13\xB8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x02lV[a\x13\xC4\x82a\x07\xDFa\x1F\x8FV[\x81\x14a\x148W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x02lV[a\x14A\x85a\x19\xB5V[a\x14J\x87a\x19\xB5V[\x14a\x14\xBDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x02lV[_a\x14\xC7\x85a\x16\xA9V[\x90P_a\x14\xF9a\x14\xD6\x89a\x16\xA9V[a\x14\xDF\x8Aa\x19\xC7V[c\xFF\xFF\xFF\xFF\x16a\x14\xEE\x8Aa\x19\xC7V[c\xFF\xFF\xFF\xFF\x16a\x19\xFAV[\x90P\x81\x81\x83\x16\x14a\x15LW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[_a\x15V\x89a\x19\xB5V[\x90P\x80`\x06T\x14\x15\x80\x15a\x15\x80WPa\x07\xE0a\x15s`\x01Ta\x0B\xCBV[a\x15}\x91\x90a\x1F\xB5V[\x84\x11[\x15a\x15\x8BW`\x06\x81\x90U[a\x15\x97\x88\x88`\x01a\x0C\x88V[\x99\x98PPPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\x15\xDAW\x85\x82\x03a\x15\xC2W`\x01\x92PPPa\tWV[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x15\xA8V[P_\x95\x94PPPPPV[_a\x15\xEF\x82a\x0B\xCBV[a\x15\xFA`\x01Ta\x0B\xCBV[a\x04-\x91\x90a\x1F\xB5V[_` \x84Qa\x16\x13\x91\x90a\x1F\x06V[\x15a\x16\x1FWP_a\x05\xECV[\x83Q_\x03a\x16.WP_a\x05\xECV[\x81\x85_[\x86Q\x81\x10\x15a\x16\x9CWa\x16F`\x02\x84a\x1F\x06V[`\x01\x03a\x16jWa\x16ca\x16]\x88\x83\x01` \x01Q\x90V[\x83a\x1A\x8CV[\x91Pa\x16\x83V[a\x16\x80\x82a\x16{\x89\x84\x01` \x01Q\x90V[a\x1A\x8CV[\x91P[`\x01\x92\x90\x92\x1C\x91a\x16\x95` \x82a\x1F\x8FV[\x90Pa\x162V[P\x90\x93\x14\x95\x94PPPPPV[_a\x04-\x82_a\x16\xD9V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x16\xF0a\x16\xE9\x84`Ha\x1F\x8FV[\x85\x90a\x1A\x97V[`\xE8\x1C\x90P_\x84a\x17\x02\x85`Ka\x1F\x8FV[\x81Q\x81\x10a\x17\x12Wa\x17\x12a\x1F\xC8V[\x01` \x01Q`\xF8\x1C\x90P_a\x17D\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x17W`\x03\x84a\x1F\xF5V[`\xFF\x16\x90Pa\x17h\x81a\x01\0a \xF1V[a\x07^\x90\x83a \xFCV[_a\x04*a\x17\x81\x83`\x04a\x1F\x8FV[\x84\x01` \x01Q\x90V[_\x83\x85\x14\x80\x15a\x17\x99WP\x82\x85\x14[\x15a\x17\xA6WP`\x01a\x05\xECV[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x17\xEEW\x89\x83\x14a\x17\xCDW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x17\xE6W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x17\xACV[P\x82\x84\x03a\x18\x02W_\x94PPPPPa\x05\xECV[\x80\x82\x14a\x18\x15W_\x94PPPPPa\x05\xECV[P`\x01\x98\x97PPPPPPPPV[__a\x18/\x85a\x0B\xCBV[\x90P_a\x18>a\x13 \x86a\n\x81V[\x90P_a\x18Ma\x13 \x86a\n\x81V[\x90P\x82\x82\x10\x15\x80\x15a\x18_WP\x82\x81\x10\x15[a\x18\xD1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02lV[_a\x18\xDEa\x07\xE0\x85a\x1F\x06V[a\x18\xEA\x85a\x07\xE0a\x1F\x8FV[a\x18\xF4\x91\x90a\x1F\xB5V[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x19\x06WP\x80[\x15a\x19!Wa\x19\x14\x89a\n\x81V[\x96PPPPPPPa\tWV[\x81\x80\x15a\x19,WP\x80\x15[\x15a\x19:Wa\x19\x14\x88a\n\x81V[\x81\x80\x15a\x19DWP\x80[\x15a\x19hW\x83\x85\x10\x15a\x19_Wa\x19Z\x88a\n\x81V[a\x19\x14V[a\x19\x14\x89a\n\x81V[a\x19q\x88a\x19\xB5V[a\x19}a\x07\xE0\x86a\x1F\x06V[a\x19\x87\x91\x90a \xFCV[a\x19\x90\x8Aa\x19\xB5V[a\x19\x9Ca\x07\xE0\x88a\x1F\x06V[a\x19\xA6\x91\x90a \xFCV[\x10\x15a\x19_Wa\x19\x14\x88a\n\x81V[_a\x04-a\x19\xC2\x83a\x16\xA9V[a\x1A\xA5V[_a\x04-a\x19\xD4\x83a\x1A\xCCV[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1A\x06\x83\x85a\x1A\xD8V[\x90Pa\x1A\x16b\x12u\0`\x04a\x1B3V[\x81\x10\x15a\x1A.Wa\x1A+b\x12u\0`\x04a\x1B3V[\x90P[a\x1AV[\x81\x11\x15a\x1ATWa\x1AQb\x12u\0`\x04a\x1B>V[\x90P[_a\x1Al\x82a\x1Af\x88b\x01\0\0a\x1B3V[\x90a\x1B>V[\x90Pa\x1A\x82b\x01\0\0a\x1Af\x83b\x12u\0a\x1B3V[\x96\x95PPPPPPV[_a\x04*\x83\x83a\x1B\xB1V[_a\x04*\x83\x83\x01` \x01Q\x90V[_a\x04-{\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\x83a\x1B3V[_a\x04-\x82`Da\x1A\x97V[_\x82\x82\x11\x15a\x1B)W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x02lV[a\x04*\x82\x84a\x1F\xB5V[_a\x04*\x82\x84a\x1F\xA2V[_\x82_\x03a\x1BMWP_a\x04-V[a\x1BW\x82\x84a \xFCV[\x90P\x81a\x1Bd\x84\x83a\x1F\xA2V[\x14a\x04-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x02lV[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1B\xE8W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1B\xFFW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1C\x16W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1C-W__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1CHW__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1C^W__\xFD[a\x1Cj\x8A\x82\x8B\x01a\x1B\xD8V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1C\x89W__\xFD[a\x1C\x95\x8A\x82\x8B\x01a\x1B\xD8V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1C\xB5`\x80\x89\x01a\x1C\x1DV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[__`@\x83\x85\x03\x12\x15a\x1C\xD4W__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1C\xF3W__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1D\rW__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D#W__\xFD[a\x1D/\x87\x82\x88\x01a\x1B\xD8V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DNW__\xFD[a\x1DZ\x87\x82\x88\x01a\x1B\xD8V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1D{W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\x98W__\xFD[a\x1D\xA4\x89\x82\x8A\x01a\x1B\xD8V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xC3W__\xFD[a\x1D\xCF\x89\x82\x8A\x01a\x1B\xD8V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1D\xFCW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x12W__\xFD[a\x1E\x1E\x89\x82\x8A\x01a\x1B\xD8V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E=W__\xFD[a\x1EI\x89\x82\x8A\x01a\x1B\xD8V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1EhW__\xFD[a\x1Et\x89\x82\x8A\x01a\x1B\xD8V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[___``\x84\x86\x03\x12\x15a\x1E\x98W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x1E\xC0W__\xFD[\x825\x91Pa\x1E\xD0` \x84\x01a\x1C\x1DV[\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`\x12`\x04R`$_\xFD[_\x82a\x1F\x14Wa\x1F\x14a\x1E\xD9V[P\x06\x90V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x1F?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`\x11`\x04R`$_\xFD[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x04-Wa\x04-a\x1FFV[\x80\x82\x01\x80\x82\x11\x15a\x04-Wa\x04-a\x1FFV[_\x82a\x1F\xB0Wa\x1F\xB0a\x1E\xD9V[P\x04\x90V[\x81\x81\x03\x81\x81\x11\x15a\x04-Wa\x04-a\x1FFV[\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[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x04-Wa\x04-a\x1FFV[`\x01\x81[`\x01\x84\x11\x15a IW\x80\x85\x04\x81\x11\x15a -Wa -a\x1FFV[`\x01\x84\x16\x15a ;W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a \x12V[\x93P\x93\x91PPV[_\x82a _WP`\x01a\x04-V[\x81a kWP_a\x04-V[\x81`\x01\x81\x14a \x81W`\x02\x81\x14a \x8BWa \xA7V[`\x01\x91PPa\x04-V[`\xFF\x84\x11\x15a \x9CWa \x9Ca\x1FFV[PP`\x01\x82\x1Ba\x04-V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a \xCAWP\x81\x81\na\x04-V[a \xD6_\x19\x84\x84a \x0EV[\x80_\x19\x04\x82\x11\x15a \xE9Wa \xE9a\x1FFV[\x02\x93\x92PPPV[_a\x04*\x83\x83a QV[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x04-Wa\x04-a\x1FFV\xFE\xA2dipfsX\"\x12 -\xAE\x13\x86dS\xC0t\"\xFF\xF1\xAF\xA1\n\tl\xBB\xFA\xC6\xFBv\xC8\xB1\x11\xA2\x02}+\xDB\xEF\x8E\xE7dsolcC\0\x08\x1C\x003", + b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xE5W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\x88W\x80c\xB9\x85b\x1A\x11a\0cW\x80c\xB9\x85b\x1A\x14a\x01\xB1W\x80c\xC5\x82B\xCD\x14a\x01\xC4W\x80c\xE3\xD8\xD8\xD8\x14a\x01\xCCW\x80c\xE4q\xE7,\x14a\x01\xD3W__\xFD[\x80cp\xD5<\x18\x14a\x01nW\x80ct\xC3\xA3\xA9\x14a\x01\x8BW\x80c\x7F\xA67\xFC\x14a\x01\x9EW__\xFD[\x80c+\x97\xBE$\x11a\0\xC3W\x80c+\x97\xBE$\x14a\x01\x1DW\x80c0\x01{;\x14a\x01%W\x80c`\xB5\xC3\x90\x14a\x018W\x80ce\xDAA\xB9\x14a\x01KW__\xFD[\x80c\x05\xD0\x9Ap\x14a\0\xE9W\x80c\x117d\xBE\x14a\0\xFEW\x80c\x19\x10\xD9s\x14a\x01\x15W[__\xFD[a\0\xFCa\0\xF76`\x04a\x1C2V[a\x01\xE6V[\0[`\x05T[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[`\x01Ta\x01\x02V[`\x06Ta\x01\x02V[a\x01\x02a\x0136`\x04a\x1C\xC3V[a\x04\x1FV[a\x01\x02a\x01F6`\x04a\x1C\xE3V[a\x043V[a\x01^a\x01Y6`\x04a\x1C\xFAV[a\x04=V[`@Q\x90\x15\x15\x81R` \x01a\x01\x0CV[a\x01v`\x04\x81V[`@Qc\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\x01\x0CV[a\x01^a\x01\x996`\x04a\x1DfV[a\x05\xF4V[a\x01^a\x01\xAC6`\x04a\x1D\xE7V[a\x07iV[a\x01^a\x01\xBF6`\x04a\x1E\x86V[a\tHV[`\x02Ta\x01\x02V[_Ta\x01\x02V[a\0\xFCa\x01\xE16`\x04a\x1E\xAFV[a\t^V[a\x02$\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\x91RPa\n&\x92PPPV[a\x02uW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FBad header block\0\0\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[a\x02\xB3\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\n-\x92PPPV[a\x02\xFFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7FBad merkle array proof\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[a\x03~\x83a\x03A\x89\x89\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\nC\x92PPPV[\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\x91RP\x88\x92Pa\nO\x91PPV[a\x03\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FBad inclusion proof\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[_a\x04\t\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_\x92\x01\x91\x90\x91RPa\n\x81\x92PPPV[\x90Pa\x04\x15\x81\x83a\t^V[PPPPPPPPV[_a\x04*\x83\x83a\x0BYV[\x90P[\x92\x91PPV[_a\x04-\x82a\x0B\xCBV[_a\x04|\x83\x83\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\x0Cy\x92PPPV[a\x04\xEEW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`+`$\x82\x01R\x7FHeader array length must be divi`D\x82\x01R\x7Fsible by 80\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\x02lV[a\x05,\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\n&\x92PPPV[a\x05xW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7FAnchor must be 80 bytes\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[a\x05\xE9\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\x91RPP`@\x80Q` `\x1F\x89\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x87\x81R\x92P\x87\x91P\x86\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x82\x90RP\x92Pa\x0C\x88\x91PPV[\x90P[\x94\x93PPPPV[_a\x063\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\x91RPa\n&\x92PPPV[\x80\x15a\x06xWPa\x06x\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\x91RPa\n&\x92PPPV[a\x06\xEAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`.`$\x82\x01R\x7FBad args. Check header and array`D\x82\x01R\x7F byte lengths.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02lV[a\x07^\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_\x92\x01\x91\x90\x91RPP`@\x80Q` `\x1F\x8B\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x89\x81R\x92P\x89\x91P\x88\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RP\x88\x92Pa\x10u\x91PPV[\x97\x96PPPPPPPV[_a\x07\xA8\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\x91RPa\n&\x92PPPV[\x80\x15a\x07\xEDWPa\x07\xED\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\n&\x92PPPV[\x80\x15a\x082WPa\x082\x83\x83\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\x0Cy\x92PPPV[a\x08\xA4W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`.`$\x82\x01R\x7FBad args. Check header and array`D\x82\x01R\x7F byte lengths.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02lV[a\x07^\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\x91RPP`@\x80Q` `\x1F\x8B\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x89\x81R\x92P\x89\x91P\x88\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RPP`@\x80Q` `\x1F\x8A\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x88\x81R\x92P\x88\x91P\x87\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RPa\x13\x12\x92PPPV[_a\tT\x84\x84\x84a\x15\xA4V[\x90P[\x93\x92PPPV[_a\th`\x02T\x90V[\x90Pa\tw\x83\x82a\x08\0a\x15\xA4V[a\t\xC3W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FGCD does not confirm header\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[\x81`\xFF\x16a\t\xD0\x84a\x15\xE5V[`\xFF\x16\x10\x15a\n!W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient confirmations\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[PPPV[Q`P\x14\x90V[_` \x82Qa\n<\x91\x90a\x1F\x06V[\x15\x92\x91PPV[`D\x81\x01Q_\x90a\x04-V[_\x83\x85\x14\x80\x15a\n]WP\x81\x15[\x80\x15a\nhWP\x82Q\x15[\x15a\nuWP`\x01a\x05\xECV[a\x05\xE9\x85\x84\x86\x85a\x16\x04V[_`\x02\x80\x83`@Qa\n\x93\x91\x90a\x1F\x19V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\n\xAEW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xD1\x91\x90a\x1F/V[`@Q` \x01a\n\xE3\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\x90\x82\x90Ra\x0B\x1B\x91a\x1F\x19V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0B6W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04-\x91\x90a\x1F/V[_\x82\x81[\x83\x81\x10\x15a\x0B}W_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x0B]V[P\x80a\x04*W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[_\x80\x82\x81[a\x0B\xDC`\x04`\x01a\x1FsV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0C0W_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\x0C\x15W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0C(V[a\x0C\x1F\x81\x84a\x1F\x8FV[\x95\x94PPPPPV[`\x01\x01a\x0B\xD0V[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[_`P\x82Qa\n<\x91\x90a\x1F\x06V[__a\x0C\x93\x85a\n\x81V[\x90P_a\x0C\x9F\x82a\x0B\xCBV[\x90P_a\x0C\xAB\x86a\x16\xA9V[\x90P\x84\x80a\x0C\xC0WP\x80a\x0C\xBE\x88a\x16\xA9V[\x14[a\r1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x02lV[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x102Wa\rL`P\x82a\x1F\xA2V[a\rW\x90`\x01a\x1F\x8FV[a\ra\x90\x87a\x1F\x8FV[\x93Pa\ro\x8A\x82`Pa\x16\xB4V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x0FEW\x84a\x0E\xC5\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x0F\x13W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x0F.`\x04\x85a\x1F\x06V[_\x03a\x0FEW_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x0FP\x8B\x83a\x16\xD9V[\x14a\x0F\x9DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[\x86a\x0F\xA8\x8B\x83a\x17rV[\x14a\x10\x1BW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x02lV[\x82\x96P`P\x81a\x10+\x91\x90a\x1F\x8FV[\x90Pa\r9V[P\x81a\x10=\x8Ba\n\x81V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x10\xEEW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02lV[_a\x10\xF8\x84a\n\x81V[\x90P_a\x11\x04\x86a\n\x81V[\x90P`\x01T\x81\x14a\x11WW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x02lV[_\x82\x81R`\x03` R`@\x90 Ta\x11\xB1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[a\x11\xBF\x87`\x01T\x84\x87a\x17\x8AV[a\x121W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x02lV[\x81a\x12=\x88\x88\x88a\x18$V[\x14a\x12\xB0W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02lV[`\x01\x82\x90U`\x02\x87\x90U_a\x12\xC4\x86a\x19\xB5V[\x90P`\x05T\x81\x14a\x12\xD5W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x13%a\x13 \x86a\n\x81V[a\x0B\xCBV[\x90P_a\x134a\x13 \x86a\n\x81V[\x90Pa\x13Ba\x07\xE0\x82a\x1F\x06V[a\x07\xDF\x14a\x13\xB8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x02lV[a\x13\xC4\x82a\x07\xDFa\x1F\x8FV[\x81\x14a\x148W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x02lV[a\x14A\x85a\x19\xB5V[a\x14J\x87a\x19\xB5V[\x14a\x14\xBDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x02lV[_a\x14\xC7\x85a\x16\xA9V[\x90P_a\x14\xF9a\x14\xD6\x89a\x16\xA9V[a\x14\xDF\x8Aa\x19\xC7V[c\xFF\xFF\xFF\xFF\x16a\x14\xEE\x8Aa\x19\xC7V[c\xFF\xFF\xFF\xFF\x16a\x19\xFAV[\x90P\x81\x81\x83\x16\x14a\x15LW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02lV[_a\x15V\x89a\x19\xB5V[\x90P\x80`\x06T\x14\x15\x80\x15a\x15\x80WPa\x07\xE0a\x15s`\x01Ta\x0B\xCBV[a\x15}\x91\x90a\x1F\xB5V[\x84\x11[\x15a\x15\x8BW`\x06\x81\x90U[a\x15\x97\x88\x88`\x01a\x0C\x88V[\x99\x98PPPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\x15\xDAW\x85\x82\x03a\x15\xC2W`\x01\x92PPPa\tWV[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x15\xA8V[P_\x95\x94PPPPPV[_a\x15\xEF\x82a\x0B\xCBV[a\x15\xFA`\x01Ta\x0B\xCBV[a\x04-\x91\x90a\x1F\xB5V[_` \x84Qa\x16\x13\x91\x90a\x1F\x06V[\x15a\x16\x1FWP_a\x05\xECV[\x83Q_\x03a\x16.WP_a\x05\xECV[\x81\x85_[\x86Q\x81\x10\x15a\x16\x9CWa\x16F`\x02\x84a\x1F\x06V[`\x01\x03a\x16jWa\x16ca\x16]\x88\x83\x01` \x01Q\x90V[\x83a\x1A\x8CV[\x91Pa\x16\x83V[a\x16\x80\x82a\x16{\x89\x84\x01` \x01Q\x90V[a\x1A\x8CV[\x91P[`\x01\x92\x90\x92\x1C\x91a\x16\x95` \x82a\x1F\x8FV[\x90Pa\x162V[P\x90\x93\x14\x95\x94PPPPPV[_a\x04-\x82_a\x16\xD9V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x16\xF0a\x16\xE9\x84`Ha\x1F\x8FV[\x85\x90a\x1A\x97V[`\xE8\x1C\x90P_\x84a\x17\x02\x85`Ka\x1F\x8FV[\x81Q\x81\x10a\x17\x12Wa\x17\x12a\x1F\xC8V[\x01` \x01Q`\xF8\x1C\x90P_a\x17D\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x17W`\x03\x84a\x1F\xF5V[`\xFF\x16\x90Pa\x17h\x81a\x01\0a \xF1V[a\x07^\x90\x83a \xFCV[_a\x04*a\x17\x81\x83`\x04a\x1F\x8FV[\x84\x01` \x01Q\x90V[_\x83\x85\x14\x80\x15a\x17\x99WP\x82\x85\x14[\x15a\x17\xA6WP`\x01a\x05\xECV[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x17\xEEW\x89\x83\x14a\x17\xCDW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x17\xE6W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x17\xACV[P\x82\x84\x03a\x18\x02W_\x94PPPPPa\x05\xECV[\x80\x82\x14a\x18\x15W_\x94PPPPPa\x05\xECV[P`\x01\x98\x97PPPPPPPPV[__a\x18/\x85a\x0B\xCBV[\x90P_a\x18>a\x13 \x86a\n\x81V[\x90P_a\x18Ma\x13 \x86a\n\x81V[\x90P\x82\x82\x10\x15\x80\x15a\x18_WP\x82\x81\x10\x15[a\x18\xD1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x02lV[_a\x18\xDEa\x07\xE0\x85a\x1F\x06V[a\x18\xEA\x85a\x07\xE0a\x1F\x8FV[a\x18\xF4\x91\x90a\x1F\xB5V[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x19\x06WP\x80[\x15a\x19!Wa\x19\x14\x89a\n\x81V[\x96PPPPPPPa\tWV[\x81\x80\x15a\x19,WP\x80\x15[\x15a\x19:Wa\x19\x14\x88a\n\x81V[\x81\x80\x15a\x19DWP\x80[\x15a\x19hW\x83\x85\x10\x15a\x19_Wa\x19Z\x88a\n\x81V[a\x19\x14V[a\x19\x14\x89a\n\x81V[a\x19q\x88a\x19\xB5V[a\x19}a\x07\xE0\x86a\x1F\x06V[a\x19\x87\x91\x90a \xFCV[a\x19\x90\x8Aa\x19\xB5V[a\x19\x9Ca\x07\xE0\x88a\x1F\x06V[a\x19\xA6\x91\x90a \xFCV[\x10\x15a\x19_Wa\x19\x14\x88a\n\x81V[_a\x04-a\x19\xC2\x83a\x16\xA9V[a\x1A\xA5V[_a\x04-a\x19\xD4\x83a\x1A\xCCV[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1A\x06\x83\x85a\x1A\xD8V[\x90Pa\x1A\x16b\x12u\0`\x04a\x1B3V[\x81\x10\x15a\x1A.Wa\x1A+b\x12u\0`\x04a\x1B3V[\x90P[a\x1AV[\x81\x11\x15a\x1ATWa\x1AQb\x12u\0`\x04a\x1B>V[\x90P[_a\x1Al\x82a\x1Af\x88b\x01\0\0a\x1B3V[\x90a\x1B>V[\x90Pa\x1A\x82b\x01\0\0a\x1Af\x83b\x12u\0a\x1B3V[\x96\x95PPPPPPV[_a\x04*\x83\x83a\x1B\xB1V[_a\x04*\x83\x83\x01` \x01Q\x90V[_a\x04-{\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\x83a\x1B3V[_a\x04-\x82`Da\x1A\x97V[_\x82\x82\x11\x15a\x1B)W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x02lV[a\x04*\x82\x84a\x1F\xB5V[_a\x04*\x82\x84a\x1F\xA2V[_\x82_\x03a\x1BMWP_a\x04-V[a\x1BW\x82\x84a \xFCV[\x90P\x81a\x1Bd\x84\x83a\x1F\xA2V[\x14a\x04-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x02lV[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1B\xE8W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1B\xFFW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1C\x16W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1C-W__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1CHW__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1C^W__\xFD[a\x1Cj\x8A\x82\x8B\x01a\x1B\xD8V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1C\x89W__\xFD[a\x1C\x95\x8A\x82\x8B\x01a\x1B\xD8V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1C\xB5`\x80\x89\x01a\x1C\x1DV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[__`@\x83\x85\x03\x12\x15a\x1C\xD4W__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1C\xF3W__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1D\rW__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D#W__\xFD[a\x1D/\x87\x82\x88\x01a\x1B\xD8V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DNW__\xFD[a\x1DZ\x87\x82\x88\x01a\x1B\xD8V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1D{W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\x98W__\xFD[a\x1D\xA4\x89\x82\x8A\x01a\x1B\xD8V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xC3W__\xFD[a\x1D\xCF\x89\x82\x8A\x01a\x1B\xD8V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1D\xFCW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x12W__\xFD[a\x1E\x1E\x89\x82\x8A\x01a\x1B\xD8V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E=W__\xFD[a\x1EI\x89\x82\x8A\x01a\x1B\xD8V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1EhW__\xFD[a\x1Et\x89\x82\x8A\x01a\x1B\xD8V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[___``\x84\x86\x03\x12\x15a\x1E\x98W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x1E\xC0W__\xFD[\x825\x91Pa\x1E\xD0` \x84\x01a\x1C\x1DV[\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`\x12`\x04R`$_\xFD[_\x82a\x1F\x14Wa\x1F\x14a\x1E\xD9V[P\x06\x90V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x1F?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`\x11`\x04R`$_\xFD[c\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x04-Wa\x04-a\x1FFV[\x80\x82\x01\x80\x82\x11\x15a\x04-Wa\x04-a\x1FFV[_\x82a\x1F\xB0Wa\x1F\xB0a\x1E\xD9V[P\x04\x90V[\x81\x81\x03\x81\x81\x11\x15a\x04-Wa\x04-a\x1FFV[\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[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x04-Wa\x04-a\x1FFV[`\x01\x81[`\x01\x84\x11\x15a IW\x80\x85\x04\x81\x11\x15a -Wa -a\x1FFV[`\x01\x84\x16\x15a ;W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a \x12V[\x93P\x93\x91PPV[_\x82a _WP`\x01a\x04-V[\x81a kWP_a\x04-V[\x81`\x01\x81\x14a \x81W`\x02\x81\x14a \x8BWa \xA7V[`\x01\x91PPa\x04-V[`\xFF\x84\x11\x15a \x9CWa \x9Ca\x1FFV[PP`\x01\x82\x1Ba\x04-V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a \xCAWP\x81\x81\na\x04-V[a \xD6_\x19\x84\x84a \x0EV[\x80_\x19\x04\x82\x11\x15a \xE9Wa \xE9a\x1FFV[\x02\x93\x92PPPV[_a\x04*\x83\x83a QV[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x04-Wa\x04-a\x1FFV\xFE\xA2dipfsX\"\x12 \\r\xD1\xBCS+\xF3\xDF&Q\xF6\xC4i\x15\x8E\xECS\xF0\x10,\xEF\xB1\x01\x83\x9AK\xF2r\x84\xA3V\xC6dsolcC\0\x08\x1C\x003", ); #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] diff --git a/crates/bindings/src/fullrelayaddheadertest.rs b/crates/bindings/src/fullrelayaddheadertest.rs deleted file mode 100644 index 7849dcc58..000000000 --- a/crates/bindings/src/fullrelayaddheadertest.rs +++ /dev/null @@ -1,9634 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface FullRelayAddHeaderTest { - event Extension(bytes32 indexed _first, bytes32 indexed _last); - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - constructor(); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); - function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); - function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); - function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function testExtensionEventFiring() external; - function testExternalRetarget() external; - function testIInsufficientWork() external; - function testIncorrectAnchorLength() external; - function testIncorrectHeaderChainLength() external; - function testTargetCangesMidchain() external; -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getBlockHeights", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getDigestLes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes32[]", - "internalType": "bytes32[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaderHexes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes[]", - "internalType": "bytes[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaders", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "headers", - "type": "bytes", - "internalType": "bytes" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testExtensionEventFiring", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testExternalRetarget", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testIInsufficientWork", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testIncorrectAnchorLength", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testIncorrectHeaderChainLength", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testTargetCangesMidchain", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "event", - "name": "Extension", - "inputs": [ - { - "name": "_first", - "type": "bytes32", - "indexed": true, - "internalType": "bytes32" - }, - { - "name": "_last", - "type": "bytes32", - "indexed": true, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 FullRelayAddHeaderTest { - use super::*; - use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15a\0,W__\xFD[P`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k42\xB0\xB22\xB99\x9759\xB7\xB7`\xA1\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k\x05\xCC\xEC\xAD\xCC\xAEm.e\xCD\x0C\xAF`\xA3\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x0F\x81R` \x01n\x0B\x99\xD9[\x99\\\xDA\\\xCB\x9A\x19ZY\xDA\x1D`\x8A\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x18\x81R` \x01\x7F.orphan_562630.digest_le\0\0\0\0\0\0\0\0\x81RP__Q` a\\t_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x16c\xD90\xA0\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\x1EW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01E\x91\x90\x81\x01\x90a\tTV[\x90P_\x81\x86`@Q` \x01a\x01[\x92\x91\x90a\t\xAFV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Rc`\xF9\xBB\x11`\xE0\x1B\x82R\x91P_Q` a\\t_9_Q\x90_R\x90c`\xF9\xBB\x11\x90a\x01\x9B\x90\x84\x90`\x04\x01a\n!V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xB5W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01\xDC\x91\x90\x81\x01\x90a\tTV[` \x90a\x01\xE9\x90\x82a\n\xB7V[Pa\x02\x80\x85` \x80Ta\x01\xFB\x90a\n3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02'\x90a\n3V[\x80\x15a\x02rW\x80`\x1F\x10a\x02IWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02rV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02UW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x05\x1D\x91PPV[a\x03\x16\x85` \x80Ta\x02\x91\x90a\n3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\xBD\x90a\n3V[\x80\x15a\x03\x08W\x80`\x1F\x10a\x02\xDFWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\x08V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02\xEBW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x05\x9C\x91PPV[a\x03\xAC\x85` \x80Ta\x03'\x90a\n3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03S\x90a\n3V[\x80\x15a\x03\x9EW\x80`\x1F\x10a\x03uWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\x9EV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\x81W\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x06\x0F\x91PPV[`@Qa\x03\xB8\x90a\x08\xBEV[a\x03\xC4\x93\x92\x91\x90a\x0BqV[`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03\xDDW=__>=_\xFD[P`\x1F`\x01a\x01\0\n\x81T\x81`\x01`\x01`\xA0\x1B\x03\x02\x19\x16\x90\x83`\x01`\x01`\xA0\x1B\x03\x16\x02\x17\x90UPPPPPPPa\x049`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01d1\xB40\xB4\xB7`\xD9\x1B\x81RP_`\x12a\x06C` \x1B` \x1CV[`!\x90a\x04F\x90\x82a\n\xB7V[Pa\x04|`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k\x05\xCC\xEC\xAD\xCC\xAEm.e\xCD\x0C\xAF`\xA3\x1B\x81RP` \x80Ta\x01\xFB\x90a\n3V[`\"\x90a\x04\x89\x90\x82a\n\xB7V[Pa\x04\xC5`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01q\x05\xCD\xEEN\r\x0C-\xCB\xE6\xA6\xC6F\xC6f\x05\xCD\x0C\xAF`s\x1B\x81RP` \x80Ta\x01\xFB\x90a\n3V[`#\x90a\x04\xD2\x90\x82a\n\xB7V[Pa\x05\n`@Q\x80`@\x01`@R\x80`\x0E\x81R` \x01m\x05\xCCL,\x89\x0C\xAC,\x8C\xAEE\xCD\x0C\xAF`\x93\x1B\x81RP` \x80Ta\x01\xFB\x90a\n3V[`$\x90a\x05\x17\x90\x82a\n\xB7V[Pa\x0C\xCEV[`@Qc\x1F\xB2C}`\xE3\x1B\x81R``\x90_Q` a\\t_9_Q\x90_R\x90c\xFD\x92\x1B\xE8\x90a\x05R\x90\x86\x90\x86\x90`\x04\x01a\x0B\x95V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05lW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x05\x93\x91\x90\x81\x01\x90a\tTV[\x90P[\x92\x91PPV[`@QcV\xEE\xF1[`\xE1\x1B\x81R_\x90_Q` a\\t_9_Q\x90_R\x90c\xAD\xDD\xE2\xB6\x90a\x05\xD0\x90\x86\x90\x86\x90`\x04\x01a\x0B\x95V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xEBW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x93\x91\x90a\x0B\xB9V[`@Qc\x17w\xE5\x9D`\xE0\x1B\x81R_\x90_Q` a\\t_9_Q\x90_R\x90c\x17w\xE5\x9D\x90a\x05\xD0\x90\x86\x90\x86\x90`\x04\x01a\x0B\x95V[``_a\x06Q\x85\x85\x85a\x06\xB5V[\x90P_[a\x06_\x85\x85a\x0B\xE4V[\x81\x10\x15a\x06\xACW\x82\x82\x82\x81Q\x81\x10a\x06yWa\x06ya\x0B\xF7V[` \x02` \x01\x01Q`@Q` \x01a\x06\x92\x92\x91\x90a\x0C\x0BV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x06UV[PP\x93\x92PPPV[``a\x06\xE4\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01b\r\x0C\xAF`\xEB\x1B\x81RPa\x06\xEC` \x1B` \x1CV[\x94\x93PPPPV[``a\x06\xF8\x84\x84a\x0B\xE4V[`\x01`\x01`@\x1B\x03\x81\x11\x15a\x07\x0FWa\x07\x0Fa\x08\xCBV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x07BW\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x07-W\x90P[P\x90P\x83[\x83\x81\x10\x15a\x07\xB9Wa\x07\x8B\x86a\x07\\\x83a\x07\xC2V[\x85`@Q` \x01a\x07o\x93\x92\x91\x90a\x0C\x1FV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x01\xFB\x90a\n3V[\x82a\x07\x96\x87\x84a\x0B\xE4V[\x81Q\x81\x10a\x07\xA6Wa\x07\xA6a\x0B\xF7V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x07GV[P\x94\x93PPPPV[``\x81_\x03a\x07\xE8WPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R`\x03`\xFC\x1B` \x82\x01R\x90V[\x81_[\x81\x15a\x08\x11W\x80a\x07\xFB\x81a\x0CiV[\x91Pa\x08\n\x90P`\n\x83a\x0C\x95V[\x91Pa\x07\xEBV[_\x81`\x01`\x01`@\x1B\x03\x81\x11\x15a\x08*Wa\x08*a\x08\xCBV[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x08TW` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x06\xE4Wa\x08i`\x01\x83a\x0B\xE4V[\x91Pa\x08v`\n\x86a\x0C\xA8V[a\x08\x81\x90`0a\x0C\xBBV[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x08\x96Wa\x08\x96a\x0B\xF7V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SPa\x08\xB7`\n\x86a\x0C\x95V[\x94Pa\x08XV[a);\x80a39\x839\x01\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x80`\x01`\x01`@\x1B\x03\x84\x11\x15a\x08\xF8Wa\x08\xF8a\x08\xCBV[P`@Q`\x1F\x19`\x1F\x85\x01\x81\x16`?\x01\x16\x81\x01\x81\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17\x15a\t&Wa\t&a\x08\xCBV[`@R\x83\x81R\x90P\x80\x82\x84\x01\x85\x10\x15a\t=W__\xFD[\x83\x83` \x83\x01^_` \x85\x83\x01\x01RP\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\tdW__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\tyW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\t\x89W__\xFD[a\x06\xE4\x84\x82Q` \x84\x01a\x08\xDFV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\t\xBA\x82\x85a\t\x98V[\x7F/test/fullRelay/testData/\0\0\0\0\0\0\0\x81Ra\t\xEA`\x19\x82\x01\x85a\t\x98V[\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R_a\x05\x93` \x83\x01\x84a\t\xF3V[`\x01\x81\x81\x1C\x90\x82\x16\x80a\nGW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\neWcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\n\xB2W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\n\x90WP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\n\xAFW_\x81U`\x01\x01a\n\x9CV[PP[PPPV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\n\xD0Wa\n\xD0a\x08\xCBV[a\n\xE4\x81a\n\xDE\x84Ta\n3V[\x84a\nkV[` `\x1F\x82\x11`\x01\x81\x14a\x0B\x16W_\x83\x15a\n\xFFWP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\n\xAFV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x0BEW\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x0B%V[P\x84\x82\x10\x15a\x0BbW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[``\x81R_a\x0B\x83``\x83\x01\x86a\t\xF3V[` \x83\x01\x94\x90\x94RP`@\x01R\x91\x90PV[`@\x81R_a\x0B\xA7`@\x83\x01\x85a\t\xF3V[\x82\x81\x03` \x84\x01Ra\t\xEA\x81\x85a\t\xF3V[_` \x82\x84\x03\x12\x15a\x0B\xC9W__\xFD[PQ\x91\x90PV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x05\x96Wa\x05\x96a\x0B\xD0V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[_a\x06\xE4a\x0C\x19\x83\x86a\t\x98V[\x84a\t\x98V[`\x17`\xF9\x1B\x81R_a\x0C4`\x01\x83\x01\x86a\t\x98V[`[`\xF8\x1B\x81Ra\x0CH`\x01\x82\x01\x86a\t\x98V[\x90Pa.\x97`\xF1\x1B\x81Ra\x0C_`\x02\x82\x01\x85a\t\x98V[\x96\x95PPPPPPV[_`\x01\x82\x01a\x0CzWa\x0Cza\x0B\xD0V[P`\x01\x01\x90V[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x0C\xA3Wa\x0C\xA3a\x0C\x81V[P\x04\x90V[_\x82a\x0C\xB6Wa\x0C\xB6a\x0C\x81V[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a\x05\x96Wa\x05\x96a\x0B\xD0V[a&^\x80a\x0C\xDB_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01yW_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\xD2W\x80c\xB5P\x8A\xA9\x11a\0\x88W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x02\xB9W\x80c\xFAv&\xD4\x14a\x02\xC1W\x80c\xFA\xD0k\x8F\x14a\x02\xCEW__\xFD[\x80c\xB5P\x8A\xA9\x14a\x02\x91W\x80c\xBAAO\xA6\x14a\x02\x99W\x80c\xDC0\xF7\xD1\x14a\x02\xB1W__\xFD[\x80c\x9B\xFC\x92z\x11a\0\xB8W\x80c\x9B\xFC\x92z\x14a\x02yW\x80c\xA1G?\xA7\x14a\x02\x81W\x80c\xB0FO\xDC\x14a\x02\x89W__\xFD[\x80c\x91j\x17\xC6\x14a\x02\\W\x80c\x9A\xDC\n\x0F\x14a\x02qW__\xFD[\x80c>^<#\x11a\x012W\x80cf\xD9\xA9\xA0\x11a\x01\rW\x80cf\xD9\xA9\xA0\x14a\x02*W\x80cz\xC3\x1FX\x14a\x02?W\x80c\x85\"l\x81\x14a\x02GW__\xFD[\x80c>^<#\x14a\x01\xFAW\x80c?r\x86\xF4\x14a\x02\x02W\x80cD\xBA\xDB\xB6\x14a\x02\nW__\xFD[\x80c\x1E\xD7\x83\x1C\x11a\x01bW\x80c\x1E\xD7\x83\x1C\x14a\x01\xC6W\x80c*\xDE8\x80\x14a\x01\xDBW\x80c/E\xB0e\x14a\x01\xF0W__\xFD[\x80c\x08\x13\x85*\x14a\x01}W\x80c\x1C\r\xA8\x1F\x14a\x01\xA6W[__\xFD[a\x01\x90a\x01\x8B6`\x04a\x1A\tV[a\x02\xE1V[`@Qa\x01\x9D\x91\x90a\x1A\xBEV[`@Q\x80\x91\x03\x90\xF3[a\x01\xB9a\x01\xB46`\x04a\x1A\tV[a\x03,V[`@Qa\x01\x9D\x91\x90a\x1B!V[a\x01\xCEa\x03\x9EV[`@Qa\x01\x9D\x91\x90a\x1B3V[a\x01\xE3a\x04\x0BV[`@Qa\x01\x9D\x91\x90a\x1B\xE5V[a\x01\xF8a\x05TV[\0[a\x01\xCEa\x06\xA0V[a\x01\xCEa\x07\x0BV[a\x02\x1Da\x02\x186`\x04a\x1A\tV[a\x07vV[`@Qa\x01\x9D\x91\x90a\x1CiV[a\x022a\x07\xB9V[`@Qa\x01\x9D\x91\x90a\x1C\xFCV[a\x01\xF8a\t2V[a\x02Oa\n\x84V[`@Qa\x01\x9D\x91\x90a\x1DzV[a\x02da\x0BOV[`@Qa\x01\x9D\x91\x90a\x1D\x8CV[a\x01\xF8a\x0CRV[a\x01\xF8a\x0C\xC1V[a\x01\xF8a\raV[a\x02da\r\xD3V[a\x02Oa\x0E\xD6V[a\x02\xA1a\x0F\xA1V[`@Q\x90\x15\x15\x81R` \x01a\x01\x9DV[a\x01\xF8a\x10qV[a\x01\xCEa\x12\xC8V[`\x1FTa\x02\xA1\x90`\xFF\x16\x81V[a\x02\x1Da\x02\xDC6`\x04a\x1A\tV[a\x133V[``a\x03$\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x13vV[\x94\x93PPPPV[``_a\x03:\x85\x85\x85a\x02\xE1V[\x90P_[a\x03H\x85\x85a\x1E=V[\x81\x10\x15a\x03\x95W\x82\x82\x82\x81Q\x81\x10a\x03bWa\x03ba\x1EPV[` \x02` \x01\x01Q`@Q` \x01a\x03{\x92\x91\x90a\x1E\x94V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x03>V[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x01W` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xD6W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x054W\x83\x82\x90_R` _ \x01\x80Ta\x04\xA9\x90a\x1E\xA8V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x04\xD5\x90a\x1E\xA8V[\x80\x15a\x05 W\x80`\x1F\x10a\x04\xF7Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05 V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05\x03W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x04\x8CV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x04.V[PPPP\x90P\x90V[`@\x80Q\x80\x82\x01\x82R`\x17\x81R\x7FAnchor must be 80 bytes\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x05\xD5\x91\x90`\x04\x01a\x1B!V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05\xECW__\xFD[PZ\xF1\x15\x80\x15a\x05\xFEW=__>=_\xFD[PP`\x1FT`@Q\x7Fe\xDAA\xB9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92Pce\xDAA\xB9\x91Pa\x06]\x90`!\x90`\x04\x01a\x1F\x96V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x06yW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x9D\x91\x90a\x1F\xDCV[PV[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x01W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xD6WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x01W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xD6WPPPPP\x90P\x90V[``a\x03$\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x14\xD7V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x08\x0C\x90a\x1E\xA8V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x088\x90a\x1E\xA8V[\x80\x15a\x08\x83W\x80`\x1F\x10a\x08ZWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x08\x83V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x08fW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\t\x1AW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x08\xC7W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07\xDCV[_`@Q\x80a\x02`\x01`@R\x80a\x020\x81R` \x01a#\xD5a\x020\x919\x90Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xF2\x8D\xCE\xB3`@Q\x80``\x01`@R\x80`$\x81R` \x01a&\x05`$\x919`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\t\xB6\x91\x90a\x1B!V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t\xCDW__\xFD[PZ\xF1\x15\x80\x15a\t\xDFW=__>=_\xFD[PP`\x1FT`@Q\x7Fe\xDAA\xB9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92Pce\xDAA\xB9\x91Pa\n@\x90`\"\x90\x85\x90`\x04\x01a \x02V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\n\\W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\x80\x91\x90a\x1F\xDCV[PPV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW\x83\x82\x90_R` _ \x01\x80Ta\n\xC4\x90a\x1E\xA8V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n\xF0\x90a\x1E\xA8V[\x80\x15a\x0B;W\x80`\x1F\x10a\x0B\x12Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B;V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\x1EW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\n\xA7V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C:W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0B\xE7W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0BrV[_`!`@Q` \x01a\x0Ce\x91\x90a \xB8V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R``\x83\x01\x90\x91R`+\x80\x83R\x90\x92Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a#\xAA` \x83\x019`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\t\xB6\x91\x90a\x1B!V[_`!`@Q` \x01a\x0C\xD4\x91\x90a \xF0V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x82\x82\x01\x82R`\x1B\x83R\x7FHeader work is insufficient\0\0\0\0\0` \x84\x01R\x90Q\x7F\xF2\x8D\xCE\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\x90\x92Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\t\xB6\x91\x90`\x04\x01a\x1B!V[_`\"`$`@Q` \x01a\rw\x92\x91\x90a!\x15V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R``\x83\x01\x90\x91R`&\x80\x83R\x90\x92Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a#\x84` \x83\x019`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\t\xB6\x91\x90a\x1B!V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0E\xBEW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0EkW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\r\xF6V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW\x83\x82\x90_R` _ \x01\x80Ta\x0F\x16\x90a\x1E\xA8V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0FB\x90a\x1E\xA8V[\x80\x15a\x0F\x8DW\x80`\x1F\x10a\x0FdWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F\x8DV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0FpW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0E\xF9V[`\x08T_\x90`\xFF\x16\x15a\x0F\xB8WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10j\x91\x90a!)V[\x14\x15\x90P\x90V[_a\x11B`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01\x7F.genesis.digest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x80Ta\x10\xB8\x90a\x1E\xA8V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x10\xE4\x90a\x1E\xA8V[\x80\x15a\x11/W\x80`\x1F\x10a\x11\x06Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x11/V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x11\x12W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x15\x7F\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90P_a\x11\x88a\x11\\a\x11W`\x01`\x12a\x1E=V[a\x16\x1BV[`@Q` \x01a\x11l\x91\x90a!@V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x10\xB8\x90a\x1E\xA8V[\x90Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cD\x0E\xD1\r`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x11\xE3W__\xFD[PZ\xF1\x15\x80\x15a\x11\xF5W=__>=_\xFD[PP`@Q\x83\x92P\x84\x91P\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3`\x1FT`@Q\x7Fe\xDAA\xB9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90ce\xDAA\xB9\x90a\x12\x83\x90`\"\x90`!\x90`\x04\x01a!\x9EV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x12\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xC3\x91\x90a\x1F\xDCV[PPPV[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x01W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xD6WPPPPP\x90P\x90V[``a\x03$\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x17LV[``a\x13\x82\x84\x84a\x1E=V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x13\x9AWa\x13\x9Aa\x19\x84V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x13\xCDW\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x13\xB8W\x90P[P\x90P\x83[\x83\x81\x10\x15a\x14\xCEWa\x14\xA0\x86a\x13\xE7\x83a\x16\x1BV[\x85`@Q` \x01a\x13\xFA\x93\x92\x91\x90a!\xC2V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x14\x16\x90a\x1E\xA8V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x14B\x90a\x1E\xA8V[\x80\x15a\x14\x8DW\x80`\x1F\x10a\x14dWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x14\x8DV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x14pW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x18\x9A\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x14\xAB\x87\x84a\x1E=V[\x81Q\x81\x10a\x14\xBBWa\x14\xBBa\x1EPV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x13\xD2V[P\x94\x93PPPPV[``a\x14\xE3\x84\x84a\x1E=V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x14\xFBWa\x14\xFBa\x19\x84V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x15$W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x14\xCEWa\x15Q\x86a\x15>\x83a\x16\x1BV[\x85`@Q` \x01a\x11l\x93\x92\x91\x90a!\xC2V[\x82a\x15\\\x87\x84a\x1E=V[\x81Q\x81\x10a\x15lWa\x15la\x1EPV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x15)V[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x15\xD3\x90\x86\x90\x86\x90`\x04\x01a\"_V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x15\xEEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x16\x12\x91\x90a!)V[\x90P[\x92\x91PPV[``\x81_\x03a\x16]WPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x16\x86W\x80a\x16p\x81a\"qV[\x91Pa\x16\x7F\x90P`\n\x83a\"\xD5V[\x91Pa\x16`V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\xA0Wa\x16\xA0a\x19\x84V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x16\xCAW` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x03$Wa\x16\xDF`\x01\x83a\x1E=V[\x91Pa\x16\xEC`\n\x86a\"\xE8V[a\x16\xF7\x90`0a\"\xFBV[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x17\x0CWa\x17\x0Ca\x1EPV[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x17E`\n\x86a\"\xD5V[\x94Pa\x16\xCEV[``a\x17X\x84\x84a\x1E=V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17pWa\x17pa\x19\x84V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x17\x99W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x14\xCEWa\x18l\x86a\x17\xB3\x83a\x16\x1BV[\x85`@Q` \x01a\x17\xC6\x93\x92\x91\x90a!\xC2V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x17\xE2\x90a\x1E\xA8V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x18\x0E\x90a\x1E\xA8V[\x80\x15a\x18YW\x80`\x1F\x10a\x180Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x18YV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x18=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x16\x12\x91\x90\x81\x01\x90a#\x0EV[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x15\xD3\x90\x86\x90\x86\x90`\x04\x01a\"_V[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x19\xDAWa\x19\xDAa\x19\x84V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x19\xFBWa\x19\xFBa\x19\x84V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x1A\x1BW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1A1W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x1AAW__\xFD[\x805a\x1ATa\x1AO\x82a\x19\xE2V[a\x19\xB1V[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x1AhW__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1B\x15W`?\x19\x87\x86\x03\x01\x84Ra\x1B\0\x85\x83Qa\x1A\x90V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1A\xE4V[P\x92\x96\x95PPPPPPV[` \x81R_a\x16\x12` \x83\x01\x84a\x1A\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1B\x80W\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\x1BLV[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x1B\xD9W`\x1F\x19\x85\x84\x03\x01\x88Ra\x1B\xC3\x83\x83Qa\x1A\x90V[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x1B\xA7V[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1B\x15W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1CS`@\x87\x01\x82a\x1B\x8BV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1C\x0BV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1B\x80W\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1C\x82V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x1C\xF2W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x1C\xB2V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1B\x15W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x1DH`@\x88\x01\x82a\x1A\x90V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x1Dc\x81\x83a\x1C\xA0V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1D\"V[` \x81R_a\x16\x12` \x83\x01\x84a\x1B\x8BV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1B\x15W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1D\xFA`@\x87\x01\x82a\x1C\xA0V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1D\xB2V[\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\x16\x15Wa\x16\x15a\x1E\x10V[\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x03$a\x1E\xA2\x83\x86a\x1E}V[\x84a\x1E}V[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1E\xBCW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x1E\xF3W\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[P\x91\x90PV[_\x81Ta\x1F\x05\x81a\x1E\xA8V[\x80\x85R`\x01\x82\x16\x80\x15a\x1F\x1FW`\x01\x81\x14a\x1FYWa\x1F\x8DV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x83\x16` \x87\x01R` \x82\x15\x15`\x05\x1B\x87\x01\x01\x93Pa\x1F\x8DV[\x84_R` _ _[\x83\x81\x10\x15a\x1F\x84W\x81T` \x82\x8A\x01\x01R`\x01\x82\x01\x91P` \x81\x01\x90Pa\x1FbV[\x87\x01` \x01\x94PP[PPP\x92\x91PPV[`@\x81R`\x02`@\x82\x01R\x7F00\0\0\0\0\0\0\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`\x80` \x82\x01R_a\x16\x12`\x80\x83\x01\x84a\x1E\xF9V[_` \x82\x84\x03\x12\x15a\x1F\xECW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x1F\xFBW__\xFD[\x93\x92PPPV[`@\x81R_a \x14`@\x83\x01\x85a\x1E\xF9V[\x82\x81\x03` \x84\x01Ra &\x81\x85a\x1A\x90V[\x95\x94PPPPPV[_\x81Ta ;\x81a\x1E\xA8V[`\x01\x82\x16\x80\x15a RW`\x01\x81\x14a \x85Wa\x1F\x8DV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x83\x16\x86R\x81\x15\x15\x82\x02\x86\x01\x93Pa\x1F\x8DV[\x84_R` _ _[\x83\x81\x10\x15a \xAAW\x81T\x88\x82\x01R`\x01\x90\x91\x01\x90` \x01a \x8EV[PPP\x93\x90\x93\x01\x93\x92PPPV[_a \xC3\x82\x84a /V[\x7FB\0\0\0\0\0\0\0\0\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\x93\x92PPPV[_a \xFB\x82\x84a /V[_\x80\x82R` \x82\x01\x81\x90R`@\x82\x01R`P\x01\x93\x92PPPV[_a\x03$a!#\x83\x86a /V[\x84a /V[_` \x82\x84\x03\x12\x15a!9W__\xFD[PQ\x91\x90PV[\x7F.chain[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R_a!q`\x07\x83\x01\x84a\x1E}V[\x7F].digest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x0B\x01\x93\x92PPPV[`@\x81R_a!\xB0`@\x83\x01\x85a\x1E\xF9V[\x82\x81\x03` \x84\x01Ra &\x81\x85a\x1E\xF9V[\x7F.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R_a!\xF3`\x01\x83\x01\x86a\x1E}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\x81Ra\"#`\x01\x82\x01\x86a\x1E}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\x81Ra\"U`\x02\x82\x01\x85a\x1E}V[\x96\x95PPPPPPV[`@\x81R_a \x14`@\x83\x01\x85a\x1A\x90V[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\"\xA1Wa\"\xA1a\x1E\x10V[P`\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`\x12`\x04R`$_\xFD[_\x82a\"\xE3Wa\"\xE3a\"\xA8V[P\x04\x90V[_\x82a\"\xF6Wa\"\xF6a\"\xA8V[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a\x16\x15Wa\x16\x15a\x1E\x10V[_` \x82\x84\x03\x12\x15a#\x1EW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a#4W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a#DW__\xFD[\x80Qa#Ra\x1AO\x82a\x19\xE2V[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a#fW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV\xFEHeaders do not form a consistent chainHeader array length must be divisible by 80\0\0\0 s\xBD!\x84\xED\xD9\xC4\xFCvd.\xA6uN\xE4\x016\x97\x0E\xFC\x10\xC4\x19\0\0\0\0\0\0\0\0\0\x02\x96\xEF\x12>\xA9m\xA5\xCFi_\"\xBF}\x94\xBE\x87\xD4\x9D\xB1\xADz\xC3q\xACC\xC4\xDAAa\xC8\xC2\x164\x9C[\xA1\x19(\x17\r8x+\0\0\0 s\xBD!\x84\xED\xD9\xC4\xFCvd.\xA6uN\xE4\x016\x97\x0E\xFC\x10\xC4\x19\0\0\0\0\0\0\0\0\0Z\xF5;\x86\\'\xC6\xE9\xB5\xE5\xDBL>\xA8\xE0$\xF82\x91x\xA7\x9D\xDB9\xF7r~\xA2\xFEnh%\xD14\x9C[\xA1\x19(\x17\xE2\xD9QY\0\0\0 s\xBD!\x84\xED\xD9\xC4\xFCvd.\xA6uN\xE4\x016\x97\x0E\xFC\x10\xC4\x19\0\0\0\0\0\0\0\0\0\xC6:\x88H\xA4H\xA4<\x9ED\x02\xBD\x89?p\x1C\xD1\x18V\xE1L\xBB\xE0&i\x9E\x8F\xDCD[5\xA8\xD9<\x9C[\xA1\x19(\x17\xB9E\xDCl\0\0\0 \xF4\x02\xC0\xB5Q\xB9DfS2FgS\xF1\xEE\xBB\x84jd\xEF$\xC7\x17\0\0\0\0\0\0\0\0\x003\xFCh\xE0p\x96N\x90\x8D\x96\x1C\xD1\x103\x89o\xA6\xC9\xB8\xB7od\xA2\xDB~\xA9(\xAF\xA7\xE3\x04%}?\x9C[\xA1\x19(\x17ad\x14]\0\0\xFF?c\xD4\x0E\xFAF@:\xFDq\xA2T\xB5O+I[{\x01d\x99\x1C-\"\0\0\0\0\0\0\0\0\0\xF0F\xDC\x1BqV\x0B}\x07\x86\xCF\xBD\xB2Z\xE3 \xBD\x96D\xC9\x8D\\|w\xBF\x9D\xF0\\\xBE\x96!'XA\x9C[\xA1\x19(\x17\xA2\xBB,\xAA\0\0\0 \xE2\xD4\xF0\xED\xD5\xED\xD8\x0B\xDC\xB8\x80STCt|k\"\xB4\x8F\xB6 \r\0\0\0\0\0\0\0\0\0\x1D7\x99\xAA>\xB8\xD1\x89\x16\xF4k\xF2\xCF\x80|\xB8\x9A\x9B\x1BLV\xC3\xF2i7\x11\xBF\x10d\xD9\xA3$5B\x9C[\xA1\x19(\x17u.I\xAE\0\0\0 \"\xDB\xA4\x1D\xFF(\xB37\xEE4c\xBF\x1A\xB1\xAC\xF0\xE5tC\xE0\xF7\xAB\x1D\0\0\0\0\0\0\0\0\0\xC3\xAA\xDC\xC8\xDE\xF0\x03\xEC\xBD\x1B\xA5\x14Y*\x18\xBA\xDD\xDD\xCD:(|\xCFt\xF5\x84\xB0L\\\x10\x04N\x97G\x9C[\xA1\x19(\x17\xC3A\xF5\x95Unexpected retarget on external call\xA2dipfsX\"\x12 \xA6\xDF\xE3W\x10\x84*\x82\xB2k\xB6\x97\xFEo~,j\x1C\xA2\x02\xE0\xA0\xA3\x9E8'\xA0\x8B\xA9\xDC\xC8\x8AdsolcC\0\x08\x1C\x003`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa);8\x03\x80a);\x839\x81\x01`@\x81\x90Ra\0.\x91a\x03+V[\x82\x82\x82\x82\x82\x82a\0?\x83Q`P\x14\x90V[a\0\x84W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x11`$\x82\x01RpBad genesis block`x\x1B`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\0\x8E\x84a\x01fV[\x90Pb\xFF\xFF\xFF\x82\x16\x15a\x01\tW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FPeriod start hash does not have `D\x82\x01R\x7Fwork. Hint: wrong byte order?\0\0\0`d\x82\x01R`\x84\x01a\0{V[_\x81\x81U`\x01\x82\x90U`\x02\x82\x90U\x81\x81R`\x04` R`@\x90 \x83\x90Ua\x012a\x07\xE0\x84a\x03\xFEV[a\x01<\x90\x84a\x04%V[_\x83\x81R`\x04` R`@\x90 Ua\x01S\x84a\x02&V[`\x05UPa\x05\xBD\x98PPPPPPPPPV[_`\x02\x80\x83`@Qa\x01x\x91\x90a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\x93W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x04NV[`@Q` \x01a\x01\xC8\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x01\xE2\x91a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\xFDW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02 \x91\x90a\x04NV[\x92\x91PPV[_a\x02 a\x023\x83a\x028V[a\x02CV[_a\x02 \x82\x82a\x02SV[_a\x02 a\xFF\xFF`\xD0\x1B\x83a\x02\xF7V[_\x80a\x02ja\x02c\x84`Ha\x04eV[\x85\x90a\x03\tV[`\xE8\x1C\x90P_\x84a\x02|\x85`Ka\x04eV[\x81Q\x81\x10a\x02\x8CWa\x02\x8Ca\x04xV[\x01` \x01Q`\xF8\x1C\x90P_a\x02\xBE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x02\xD1`\x03\x84a\x04\x8CV[`\xFF\x16\x90Pa\x02\xE2\x81a\x01\0a\x05\x88V[a\x02\xEC\x90\x83a\x05\x93V[\x97\x96PPPPPPPV[_a\x03\x02\x82\x84a\x05\xAAV[\x93\x92PPPV[_a\x03\x02\x83\x83\x01` \x01Q\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x03=W__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03RW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03bW__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03{Wa\x03{a\x03\x17V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x03\xA9Wa\x03\xA9a\x03\x17V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x03\xC0W__\xFD[\x81` \x84\x01` \x83\x01^_` \x92\x82\x01\x83\x01R\x90\x86\x01Q`@\x90\x96\x01Q\x90\x97\x95\x96P\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x04\x0CWa\x04\x0Ca\x03\xEAV[P\x06\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x04^W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02 Wa\x02 a\x04\x11V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[`\x01\x81[`\x01\x84\x11\x15a\x04\xE0W\x80\x85\x04\x81\x11\x15a\x04\xC4Wa\x04\xC4a\x04\x11V[`\x01\x84\x16\x15a\x04\xD2W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x04\xA9V[\x93P\x93\x91PPV[_\x82a\x04\xF6WP`\x01a\x02 V[\x81a\x05\x02WP_a\x02 V[\x81`\x01\x81\x14a\x05\x18W`\x02\x81\x14a\x05\"Wa\x05>V[`\x01\x91PPa\x02 V[`\xFF\x84\x11\x15a\x053Wa\x053a\x04\x11V[PP`\x01\x82\x1Ba\x02 V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x05aWP\x81\x81\na\x02 V[a\x05m_\x19\x84\x84a\x04\xA5V[\x80_\x19\x04\x82\x11\x15a\x05\x80Wa\x05\x80a\x04\x11V[\x02\x93\x92PPPV[_a\x03\x02\x83\x83a\x04\xE8V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x02 Wa\x02 a\x04\x11V[_\x82a\x05\xB8Wa\x05\xB8a\x03\xEAV[P\x04\x90V[a#q\x80a\x05\xCA_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\xADW\x80c\xB9\x85b\x1A\x11a\0}W\x80c\xE3\xD8\xD8\xD8\x11a\0cW\x80c\xE3\xD8\xD8\xD8\x14a\x02\"W\x80c\xE4q\xE7,\x14a\x02)W\x80c\xF5\x8D\xB0o\x14a\x02=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x13\x91\x90a!WV[`@Q` \x01a\x0C%\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\x90\x82\x90Ra\x0C]\x91a!AV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0CxW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x07\x91\x90a!WV[_\x83\x85\x14\x80\x15a\x0C\xAAWP\x82\x85\x14[\x15a\x0C\xB7WP`\x01a\x04\xF1V[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x0C\xFFW\x89\x83\x14a\x0C\xDEW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x0C\xF7W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x0C\xBDV[P\x82\x84\x03a\r\x13W_\x94PPPPPa\x04\xF1V[\x80\x82\x14a\r&W_\x94PPPPPa\x04\xF1V[P`\x01\x98\x97PPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\rYW_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\r9V[P\x80a\x05\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x80\x82\x81[a\r\xB8`\x04`\x01a!\x9BV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0E\x0CW_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\r\xF1W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0E\x04V[a\r\xFB\x81\x84a!\xB7V[\x95\x94PPPPPV[`\x01\x01a\r\xACV[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_`P\x82Qa\x0B~\x91\x90a!.V[__a\x0Eo\x85a\x0B\xC3V[\x90P_a\x0E{\x82a\r\xA7V[\x90P_a\x0E\x87\x86a\x19\xE6V[\x90P\x84\x80a\x0E\x9CWP\x80a\x0E\x9A\x88a\x19\xE6V[\x14[a\x0F\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x03.V[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x12\x0EWa\x0F(`P\x82a!\xCAV[a\x0F3\x90`\x01a!\xB7V[a\x0F=\x90\x87a!\xB7V[\x93Pa\x0FK\x8A\x82`Pa\x19\xF1V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x11!W\x84a\x10\xA1\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x10\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x11\n`\x04\x85a!.V[_\x03a\x11!W_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x11,\x8B\x83a\x1A\x16V[\x14a\x11yW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[\x86a\x11\x84\x8B\x83a\x1A\xAFV[\x14a\x11\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x03.V[\x82\x96P`P\x81a\x12\x07\x91\x90a!\xB7V[\x90Pa\x0F\x15V[P\x81a\x12\x19\x8Ba\x0B\xC3V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x12\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x12\xD4\x84a\x0B\xC3V[\x90P_a\x12\xE0\x86a\x0B\xC3V[\x90P`\x01T\x81\x14a\x133W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x03.V[_\x82\x81R`\x03` R`@\x90 Ta\x13\x8DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x13\x9B\x87`\x01T\x84\x87a\x0C\x9BV[a\x14\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x03.V[\x81a\x14\x19\x88\x88\x88a\x17\x80V[\x14a\x14\x8CW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[`\x01\x82\x90U`\x02\x87\x90U_a\x14\xA0\x86a\x1A\xC7V[\x90P`\x05T\x81\x14a\x14\xB1W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x15\x01a\x14\xFC\x86a\x0B\xC3V[a\r\xA7V[\x90P_a\x15\x10a\x14\xFC\x86a\x0B\xC3V[\x90Pa\x15\x1Ea\x07\xE0\x82a!.V[a\x07\xDF\x14a\x15\x94W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x03.V[a\x15\xA0\x82a\x07\xDFa!\xB7V[\x81\x14a\x16\x14W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x03.V[a\x16\x1D\x85a\x1A\xC7V[a\x16&\x87a\x1A\xC7V[\x14a\x16\x99W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x03.V[_a\x16\xA3\x85a\x19\xE6V[\x90P_a\x16\xD5a\x16\xB2\x89a\x19\xE6V[a\x16\xBB\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x16\xCA\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x1B\x0CV[\x90P\x81\x81\x83\x16\x14a\x17(W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_a\x172\x89a\x1A\xC7V[\x90P\x80`\x06T\x14\x15\x80\x15a\x17\\WPa\x07\xE0a\x17O`\x01Ta\r\xA7V[a\x17Y\x91\x90a!\xDDV[\x84\x11[\x15a\x17gW`\x06\x81\x90U[a\x17s\x88\x88`\x01a\x0EdV[\x99\x98PPPPPPPPPV[__a\x17\x8B\x85a\r\xA7V[\x90P_a\x17\x9Aa\x14\xFC\x86a\x0B\xC3V[\x90P_a\x17\xA9a\x14\xFC\x86a\x0B\xC3V[\x90P\x82\x82\x10\x15\x80\x15a\x17\xBBWP\x82\x81\x10\x15[a\x18-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x18:a\x07\xE0\x85a!.V[a\x18F\x85a\x07\xE0a!\xB7V[a\x18P\x91\x90a!\xDDV[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x18bWP\x80[\x15a\x18}Wa\x18p\x89a\x0B\xC3V[\x96PPPPPPPa\n\xA3V[\x81\x80\x15a\x18\x88WP\x80\x15[\x15a\x18\x96Wa\x18p\x88a\x0B\xC3V[\x81\x80\x15a\x18\xA0WP\x80[\x15a\x18\xC4W\x83\x85\x10\x15a\x18\xBBWa\x18\xB6\x88a\x0B\xC3V[a\x18pV[a\x18p\x89a\x0B\xC3V[a\x18\xCD\x88a\x1A\xC7V[a\x18\xD9a\x07\xE0\x86a!.V[a\x18\xE3\x91\x90a!\xF0V[a\x18\xEC\x8Aa\x1A\xC7V[a\x18\xF8a\x07\xE0\x88a!.V[a\x19\x02\x91\x90a!\xF0V[\x10\x15a\x18\xBBWa\x18p\x88a\x0B\xC3V[`\x07T_\x90`\xFF\x16\x15a\x19/WP`\x07Ta\x01\0\x90\x04`\xFF\x16a\n\xA3V[a\x19:\x84\x84\x84a\x1B\x94V[\x90Pa\n\xA3V[_` \x84Qa\x19P\x91\x90a!.V[\x15a\x19\\WP_a\x04\xF1V[\x83Q_\x03a\x19kWP_a\x04\xF1V[\x81\x85_[\x86Q\x81\x10\x15a\x19\xD9Wa\x19\x83`\x02\x84a!.V[`\x01\x03a\x19\xA7Wa\x19\xA0a\x19\x9A\x88\x83\x01` \x01Q\x90V[\x83a\x1B\xD5V[\x91Pa\x19\xC0V[a\x19\xBD\x82a\x19\xB8\x89\x84\x01` \x01Q\x90V[a\x1B\xD5V[\x91P[`\x01\x92\x90\x92\x1C\x91a\x19\xD2` \x82a!\xB7V[\x90Pa\x19oV[P\x90\x93\x14\x95\x94PPPPPV[_a\x05\x07\x82_a\x1A\x16V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x1A-a\x1A&\x84`Ha!\xB7V[\x85\x90a\x1B\xE0V[`\xE8\x1C\x90P_\x84a\x1A?\x85`Ka!\xB7V[\x81Q\x81\x10a\x1AOWa\x1AOa\"\x07V[\x01` \x01Q`\xF8\x1C\x90P_a\x1A\x81\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1A\x94`\x03\x84a\"4V[`\xFF\x16\x90Pa\x1A\xA5\x81a\x01\0a#0V[a\x08-\x90\x83a!\xF0V[_a\x05\x04a\x1A\xBE\x83`\x04a!\xB7V[\x84\x01` \x01Q\x90V[_a\x05\x07a\x1A\xD4\x83a\x19\xE6V[a\x1B\xEEV[_a\x05\x07a\x1A\xE6\x83a\x1C\x15V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1B\x18\x83\x85a\x1C!V[\x90Pa\x1B(b\x12u\0`\x04a\x1C|V[\x81\x10\x15a\x1B@Wa\x1B=b\x12u\0`\x04a\x1C|V[\x90P[a\x1BNb\x12u\0`\x04a\x1C\x87V[\x81\x11\x15a\x1BfWa\x1Bcb\x12u\0`\x04a\x1C\x87V[\x90P[_a\x1B~\x82a\x1Bx\x88b\x01\0\0a\x1C|V[\x90a\x1C\x87V[\x90Pa\n\x8Ab\x01\0\0a\x1Bx\x83b\x12u\0a\x1C|V[_\x82\x81[\x83\x81\x10\x15a\x1B\xCAW\x85\x82\x03a\x1B\xB2W`\x01\x92PPPa\n\xA3V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x1B\x98V[P_\x95\x94PPPPPV[_a\x05\x04\x83\x83a\x1C\xFAV[_a\x05\x04\x83\x83\x01` \x01Q\x90V[_a\x05\x07{\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\x83a\x1C|V[_a\x05\x07\x82`Da\x1B\xE0V[_\x82\x82\x11\x15a\x1CrW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x05\x04\x82\x84a!\xDDV[_a\x05\x04\x82\x84a!\xCAV[_\x82_\x03a\x1C\x96WP_a\x05\x07V[a\x1C\xA0\x82\x84a!\xF0V[\x90P\x81a\x1C\xAD\x84\x83a!\xCAV[\x14a\x05\x07W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x03.V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1D1W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DHW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1D_W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1DvW__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1D\x91W__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xA7W__\xFD[a\x1D\xB3\x8A\x82\x8B\x01a\x1D!V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xD2W__\xFD[a\x1D\xDE\x8A\x82\x8B\x01a\x1D!V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1D\xFE`\x80\x89\x01a\x1DfV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[____`\x80\x85\x87\x03\x12\x15a\x1E\x1FW__\xFD[PP\x825\x94` \x84\x015\x94P`@\x84\x015\x93``\x015\x92P\x90PV[__`@\x83\x85\x03\x12\x15a\x1ELW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1EkW__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1E\x85W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x9BW__\xFD[a\x1E\xA7\x87\x82\x88\x01a\x1D!V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\xC6W__\xFD[a\x1E\xD2\x87\x82\x88\x01a\x1D!V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1E\xF3W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x10W__\xFD[a\x1F\x1C\x89\x82\x8A\x01a\x1D!V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F;W__\xFD[a\x1FG\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1FtW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x8AW__\xFD[a\x1F\x96\x89\x82\x8A\x01a\x1D!V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xB5W__\xFD[a\x1F\xC1\x89\x82\x8A\x01a\x1D!V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xE0W__\xFD[a\x1F\xEC\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_____``\x86\x88\x03\x12\x15a \x12W__\xFD[\x855\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a /W__\xFD[a ;\x88\x82\x89\x01a\x1D!V[\x90\x95P\x93PP`@\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a ZW__\xFD[a f\x88\x82\x89\x01a\x1D!V[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[___``\x84\x86\x03\x12\x15a \x89W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a \xB1W__\xFD[\x825\x91Pa \xC1` \x84\x01a\x1DfV[\x90P\x92P\x92\x90PV[\x805\x80\x15\x15\x81\x14a\x1DvW__\xFD[__`@\x83\x85\x03\x12\x15a \xEAW__\xFD[a \xF3\x83a \xCAV[\x91Pa \xC1` \x84\x01a \xCAV[\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!^<#\x11a\x012W\x80cf\xD9\xA9\xA0\x11a\x01\rW\x80cf\xD9\xA9\xA0\x14a\x02*W\x80cz\xC3\x1FX\x14a\x02?W\x80c\x85\"l\x81\x14a\x02GW__\xFD[\x80c>^<#\x14a\x01\xFAW\x80c?r\x86\xF4\x14a\x02\x02W\x80cD\xBA\xDB\xB6\x14a\x02\nW__\xFD[\x80c\x1E\xD7\x83\x1C\x11a\x01bW\x80c\x1E\xD7\x83\x1C\x14a\x01\xC6W\x80c*\xDE8\x80\x14a\x01\xDBW\x80c/E\xB0e\x14a\x01\xF0W__\xFD[\x80c\x08\x13\x85*\x14a\x01}W\x80c\x1C\r\xA8\x1F\x14a\x01\xA6W[__\xFD[a\x01\x90a\x01\x8B6`\x04a\x1A\tV[a\x02\xE1V[`@Qa\x01\x9D\x91\x90a\x1A\xBEV[`@Q\x80\x91\x03\x90\xF3[a\x01\xB9a\x01\xB46`\x04a\x1A\tV[a\x03,V[`@Qa\x01\x9D\x91\x90a\x1B!V[a\x01\xCEa\x03\x9EV[`@Qa\x01\x9D\x91\x90a\x1B3V[a\x01\xE3a\x04\x0BV[`@Qa\x01\x9D\x91\x90a\x1B\xE5V[a\x01\xF8a\x05TV[\0[a\x01\xCEa\x06\xA0V[a\x01\xCEa\x07\x0BV[a\x02\x1Da\x02\x186`\x04a\x1A\tV[a\x07vV[`@Qa\x01\x9D\x91\x90a\x1CiV[a\x022a\x07\xB9V[`@Qa\x01\x9D\x91\x90a\x1C\xFCV[a\x01\xF8a\t2V[a\x02Oa\n\x84V[`@Qa\x01\x9D\x91\x90a\x1DzV[a\x02da\x0BOV[`@Qa\x01\x9D\x91\x90a\x1D\x8CV[a\x01\xF8a\x0CRV[a\x01\xF8a\x0C\xC1V[a\x01\xF8a\raV[a\x02da\r\xD3V[a\x02Oa\x0E\xD6V[a\x02\xA1a\x0F\xA1V[`@Q\x90\x15\x15\x81R` \x01a\x01\x9DV[a\x01\xF8a\x10qV[a\x01\xCEa\x12\xC8V[`\x1FTa\x02\xA1\x90`\xFF\x16\x81V[a\x02\x1Da\x02\xDC6`\x04a\x1A\tV[a\x133V[``a\x03$\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x13vV[\x94\x93PPPPV[``_a\x03:\x85\x85\x85a\x02\xE1V[\x90P_[a\x03H\x85\x85a\x1E=V[\x81\x10\x15a\x03\x95W\x82\x82\x82\x81Q\x81\x10a\x03bWa\x03ba\x1EPV[` \x02` \x01\x01Q`@Q` \x01a\x03{\x92\x91\x90a\x1E\x94V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x03>V[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x01W` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xD6W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x054W\x83\x82\x90_R` _ \x01\x80Ta\x04\xA9\x90a\x1E\xA8V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x04\xD5\x90a\x1E\xA8V[\x80\x15a\x05 W\x80`\x1F\x10a\x04\xF7Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05 V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05\x03W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x04\x8CV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x04.V[PPPP\x90P\x90V[`@\x80Q\x80\x82\x01\x82R`\x17\x81R\x7FAnchor must be 80 bytes\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x05\xD5\x91\x90`\x04\x01a\x1B!V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05\xECW__\xFD[PZ\xF1\x15\x80\x15a\x05\xFEW=__>=_\xFD[PP`\x1FT`@Q\x7Fe\xDAA\xB9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92Pce\xDAA\xB9\x91Pa\x06]\x90`!\x90`\x04\x01a\x1F\x96V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x06yW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x9D\x91\x90a\x1F\xDCV[PV[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x01W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xD6WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x01W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xD6WPPPPP\x90P\x90V[``a\x03$\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x14\xD7V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x08\x0C\x90a\x1E\xA8V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x088\x90a\x1E\xA8V[\x80\x15a\x08\x83W\x80`\x1F\x10a\x08ZWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x08\x83V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x08fW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\t\x1AW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x08\xC7W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07\xDCV[_`@Q\x80a\x02`\x01`@R\x80a\x020\x81R` \x01a#\xD5a\x020\x919\x90Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xF2\x8D\xCE\xB3`@Q\x80``\x01`@R\x80`$\x81R` \x01a&\x05`$\x919`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\t\xB6\x91\x90a\x1B!V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t\xCDW__\xFD[PZ\xF1\x15\x80\x15a\t\xDFW=__>=_\xFD[PP`\x1FT`@Q\x7Fe\xDAA\xB9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92Pce\xDAA\xB9\x91Pa\n@\x90`\"\x90\x85\x90`\x04\x01a \x02V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\n\\W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\x80\x91\x90a\x1F\xDCV[PPV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW\x83\x82\x90_R` _ \x01\x80Ta\n\xC4\x90a\x1E\xA8V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n\xF0\x90a\x1E\xA8V[\x80\x15a\x0B;W\x80`\x1F\x10a\x0B\x12Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B;V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\x1EW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\n\xA7V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C:W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0B\xE7W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0BrV[_`!`@Q` \x01a\x0Ce\x91\x90a \xB8V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R``\x83\x01\x90\x91R`+\x80\x83R\x90\x92Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a#\xAA` \x83\x019`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\t\xB6\x91\x90a\x1B!V[_`!`@Q` \x01a\x0C\xD4\x91\x90a \xF0V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x82\x82\x01\x82R`\x1B\x83R\x7FHeader work is insufficient\0\0\0\0\0` \x84\x01R\x90Q\x7F\xF2\x8D\xCE\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\x90\x92Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\t\xB6\x91\x90`\x04\x01a\x1B!V[_`\"`$`@Q` \x01a\rw\x92\x91\x90a!\x15V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R``\x83\x01\x90\x91R`&\x80\x83R\x90\x92Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a#\x84` \x83\x019`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\t\xB6\x91\x90a\x1B!V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0E\xBEW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0EkW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\r\xF6V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW\x83\x82\x90_R` _ \x01\x80Ta\x0F\x16\x90a\x1E\xA8V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0FB\x90a\x1E\xA8V[\x80\x15a\x0F\x8DW\x80`\x1F\x10a\x0FdWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F\x8DV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0FpW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0E\xF9V[`\x08T_\x90`\xFF\x16\x15a\x0F\xB8WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10j\x91\x90a!)V[\x14\x15\x90P\x90V[_a\x11B`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01\x7F.genesis.digest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x80Ta\x10\xB8\x90a\x1E\xA8V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x10\xE4\x90a\x1E\xA8V[\x80\x15a\x11/W\x80`\x1F\x10a\x11\x06Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x11/V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x11\x12W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x15\x7F\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90P_a\x11\x88a\x11\\a\x11W`\x01`\x12a\x1E=V[a\x16\x1BV[`@Q` \x01a\x11l\x91\x90a!@V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x10\xB8\x90a\x1E\xA8V[\x90Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cD\x0E\xD1\r`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x11\xE3W__\xFD[PZ\xF1\x15\x80\x15a\x11\xF5W=__>=_\xFD[PP`@Q\x83\x92P\x84\x91P\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3`\x1FT`@Q\x7Fe\xDAA\xB9\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90ce\xDAA\xB9\x90a\x12\x83\x90`\"\x90`!\x90`\x04\x01a!\x9EV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x12\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xC3\x91\x90a\x1F\xDCV[PPPV[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x01W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xD6WPPPPP\x90P\x90V[``a\x03$\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x17LV[``a\x13\x82\x84\x84a\x1E=V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x13\x9AWa\x13\x9Aa\x19\x84V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x13\xCDW\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x13\xB8W\x90P[P\x90P\x83[\x83\x81\x10\x15a\x14\xCEWa\x14\xA0\x86a\x13\xE7\x83a\x16\x1BV[\x85`@Q` \x01a\x13\xFA\x93\x92\x91\x90a!\xC2V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x14\x16\x90a\x1E\xA8V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x14B\x90a\x1E\xA8V[\x80\x15a\x14\x8DW\x80`\x1F\x10a\x14dWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x14\x8DV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x14pW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x18\x9A\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x14\xAB\x87\x84a\x1E=V[\x81Q\x81\x10a\x14\xBBWa\x14\xBBa\x1EPV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x13\xD2V[P\x94\x93PPPPV[``a\x14\xE3\x84\x84a\x1E=V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x14\xFBWa\x14\xFBa\x19\x84V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x15$W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x14\xCEWa\x15Q\x86a\x15>\x83a\x16\x1BV[\x85`@Q` \x01a\x11l\x93\x92\x91\x90a!\xC2V[\x82a\x15\\\x87\x84a\x1E=V[\x81Q\x81\x10a\x15lWa\x15la\x1EPV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x15)V[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x15\xD3\x90\x86\x90\x86\x90`\x04\x01a\"_V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x15\xEEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x16\x12\x91\x90a!)V[\x90P[\x92\x91PPV[``\x81_\x03a\x16]WPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x16\x86W\x80a\x16p\x81a\"qV[\x91Pa\x16\x7F\x90P`\n\x83a\"\xD5V[\x91Pa\x16`V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\xA0Wa\x16\xA0a\x19\x84V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x16\xCAW` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x03$Wa\x16\xDF`\x01\x83a\x1E=V[\x91Pa\x16\xEC`\n\x86a\"\xE8V[a\x16\xF7\x90`0a\"\xFBV[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x17\x0CWa\x17\x0Ca\x1EPV[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x17E`\n\x86a\"\xD5V[\x94Pa\x16\xCEV[``a\x17X\x84\x84a\x1E=V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17pWa\x17pa\x19\x84V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x17\x99W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x14\xCEWa\x18l\x86a\x17\xB3\x83a\x16\x1BV[\x85`@Q` \x01a\x17\xC6\x93\x92\x91\x90a!\xC2V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x17\xE2\x90a\x1E\xA8V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x18\x0E\x90a\x1E\xA8V[\x80\x15a\x18YW\x80`\x1F\x10a\x180Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x18YV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x18=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x16\x12\x91\x90\x81\x01\x90a#\x0EV[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x15\xD3\x90\x86\x90\x86\x90`\x04\x01a\"_V[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x19\xDAWa\x19\xDAa\x19\x84V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x19\xFBWa\x19\xFBa\x19\x84V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x1A\x1BW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1A1W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x1AAW__\xFD[\x805a\x1ATa\x1AO\x82a\x19\xE2V[a\x19\xB1V[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x1AhW__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1B\x15W`?\x19\x87\x86\x03\x01\x84Ra\x1B\0\x85\x83Qa\x1A\x90V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1A\xE4V[P\x92\x96\x95PPPPPPV[` \x81R_a\x16\x12` \x83\x01\x84a\x1A\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1B\x80W\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\x1BLV[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x1B\xD9W`\x1F\x19\x85\x84\x03\x01\x88Ra\x1B\xC3\x83\x83Qa\x1A\x90V[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x1B\xA7V[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1B\x15W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1CS`@\x87\x01\x82a\x1B\x8BV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1C\x0BV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1B\x80W\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1C\x82V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x1C\xF2W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x1C\xB2V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1B\x15W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x1DH`@\x88\x01\x82a\x1A\x90V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x1Dc\x81\x83a\x1C\xA0V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1D\"V[` \x81R_a\x16\x12` \x83\x01\x84a\x1B\x8BV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1B\x15W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1D\xFA`@\x87\x01\x82a\x1C\xA0V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1D\xB2V[\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\x16\x15Wa\x16\x15a\x1E\x10V[\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x03$a\x1E\xA2\x83\x86a\x1E}V[\x84a\x1E}V[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1E\xBCW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x1E\xF3W\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[P\x91\x90PV[_\x81Ta\x1F\x05\x81a\x1E\xA8V[\x80\x85R`\x01\x82\x16\x80\x15a\x1F\x1FW`\x01\x81\x14a\x1FYWa\x1F\x8DV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x83\x16` \x87\x01R` \x82\x15\x15`\x05\x1B\x87\x01\x01\x93Pa\x1F\x8DV[\x84_R` _ _[\x83\x81\x10\x15a\x1F\x84W\x81T` \x82\x8A\x01\x01R`\x01\x82\x01\x91P` \x81\x01\x90Pa\x1FbV[\x87\x01` \x01\x94PP[PPP\x92\x91PPV[`@\x81R`\x02`@\x82\x01R\x7F00\0\0\0\0\0\0\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`\x80` \x82\x01R_a\x16\x12`\x80\x83\x01\x84a\x1E\xF9V[_` \x82\x84\x03\x12\x15a\x1F\xECW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x1F\xFBW__\xFD[\x93\x92PPPV[`@\x81R_a \x14`@\x83\x01\x85a\x1E\xF9V[\x82\x81\x03` \x84\x01Ra &\x81\x85a\x1A\x90V[\x95\x94PPPPPV[_\x81Ta ;\x81a\x1E\xA8V[`\x01\x82\x16\x80\x15a RW`\x01\x81\x14a \x85Wa\x1F\x8DV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x83\x16\x86R\x81\x15\x15\x82\x02\x86\x01\x93Pa\x1F\x8DV[\x84_R` _ _[\x83\x81\x10\x15a \xAAW\x81T\x88\x82\x01R`\x01\x90\x91\x01\x90` \x01a \x8EV[PPP\x93\x90\x93\x01\x93\x92PPPV[_a \xC3\x82\x84a /V[\x7FB\0\0\0\0\0\0\0\0\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\x93\x92PPPV[_a \xFB\x82\x84a /V[_\x80\x82R` \x82\x01\x81\x90R`@\x82\x01R`P\x01\x93\x92PPPV[_a\x03$a!#\x83\x86a /V[\x84a /V[_` \x82\x84\x03\x12\x15a!9W__\xFD[PQ\x91\x90PV[\x7F.chain[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R_a!q`\x07\x83\x01\x84a\x1E}V[\x7F].digest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R`\x0B\x01\x93\x92PPPV[`@\x81R_a!\xB0`@\x83\x01\x85a\x1E\xF9V[\x82\x81\x03` \x84\x01Ra &\x81\x85a\x1E\xF9V[\x7F.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R_a!\xF3`\x01\x83\x01\x86a\x1E}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\x81Ra\"#`\x01\x82\x01\x86a\x1E}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\x81Ra\"U`\x02\x82\x01\x85a\x1E}V[\x96\x95PPPPPPV[`@\x81R_a \x14`@\x83\x01\x85a\x1A\x90V[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\"\xA1Wa\"\xA1a\x1E\x10V[P`\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`\x12`\x04R`$_\xFD[_\x82a\"\xE3Wa\"\xE3a\"\xA8V[P\x04\x90V[_\x82a\"\xF6Wa\"\xF6a\"\xA8V[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a\x16\x15Wa\x16\x15a\x1E\x10V[_` \x82\x84\x03\x12\x15a#\x1EW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a#4W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a#DW__\xFD[\x80Qa#Ra\x1AO\x82a\x19\xE2V[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a#fW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV\xFEHeaders do not form a consistent chainHeader array length must be divisible by 80\0\0\0 s\xBD!\x84\xED\xD9\xC4\xFCvd.\xA6uN\xE4\x016\x97\x0E\xFC\x10\xC4\x19\0\0\0\0\0\0\0\0\0\x02\x96\xEF\x12>\xA9m\xA5\xCFi_\"\xBF}\x94\xBE\x87\xD4\x9D\xB1\xADz\xC3q\xACC\xC4\xDAAa\xC8\xC2\x164\x9C[\xA1\x19(\x17\r8x+\0\0\0 s\xBD!\x84\xED\xD9\xC4\xFCvd.\xA6uN\xE4\x016\x97\x0E\xFC\x10\xC4\x19\0\0\0\0\0\0\0\0\0Z\xF5;\x86\\'\xC6\xE9\xB5\xE5\xDBL>\xA8\xE0$\xF82\x91x\xA7\x9D\xDB9\xF7r~\xA2\xFEnh%\xD14\x9C[\xA1\x19(\x17\xE2\xD9QY\0\0\0 s\xBD!\x84\xED\xD9\xC4\xFCvd.\xA6uN\xE4\x016\x97\x0E\xFC\x10\xC4\x19\0\0\0\0\0\0\0\0\0\xC6:\x88H\xA4H\xA4<\x9ED\x02\xBD\x89?p\x1C\xD1\x18V\xE1L\xBB\xE0&i\x9E\x8F\xDCD[5\xA8\xD9<\x9C[\xA1\x19(\x17\xB9E\xDCl\0\0\0 \xF4\x02\xC0\xB5Q\xB9DfS2FgS\xF1\xEE\xBB\x84jd\xEF$\xC7\x17\0\0\0\0\0\0\0\0\x003\xFCh\xE0p\x96N\x90\x8D\x96\x1C\xD1\x103\x89o\xA6\xC9\xB8\xB7od\xA2\xDB~\xA9(\xAF\xA7\xE3\x04%}?\x9C[\xA1\x19(\x17ad\x14]\0\0\xFF?c\xD4\x0E\xFAF@:\xFDq\xA2T\xB5O+I[{\x01d\x99\x1C-\"\0\0\0\0\0\0\0\0\0\xF0F\xDC\x1BqV\x0B}\x07\x86\xCF\xBD\xB2Z\xE3 \xBD\x96D\xC9\x8D\\|w\xBF\x9D\xF0\\\xBE\x96!'XA\x9C[\xA1\x19(\x17\xA2\xBB,\xAA\0\0\0 \xE2\xD4\xF0\xED\xD5\xED\xD8\x0B\xDC\xB8\x80STCt|k\"\xB4\x8F\xB6 \r\0\0\0\0\0\0\0\0\0\x1D7\x99\xAA>\xB8\xD1\x89\x16\xF4k\xF2\xCF\x80|\xB8\x9A\x9B\x1BLV\xC3\xF2i7\x11\xBF\x10d\xD9\xA3$5B\x9C[\xA1\x19(\x17u.I\xAE\0\0\0 \"\xDB\xA4\x1D\xFF(\xB37\xEE4c\xBF\x1A\xB1\xAC\xF0\xE5tC\xE0\xF7\xAB\x1D\0\0\0\0\0\0\0\0\0\xC3\xAA\xDC\xC8\xDE\xF0\x03\xEC\xBD\x1B\xA5\x14Y*\x18\xBA\xDD\xDD\xCD:(|\xCFt\xF5\x84\xB0L\\\x10\x04N\x97G\x9C[\xA1\x19(\x17\xC3A\xF5\x95Unexpected retarget on external call\xA2dipfsX\"\x12 \xA6\xDF\xE3W\x10\x84*\x82\xB2k\xB6\x97\xFEo~,j\x1C\xA2\x02\xE0\xA0\xA3\x9E8'\xA0\x8B\xA9\xDC\xC8\x8AdsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `Extension(bytes32,bytes32)` and selector `0xf90e4f1d9cd0dd55e339411cbc9b152482307c3a23ed64715e4a2858f641a3f5`. -```solidity -event Extension(bytes32 indexed _first, bytes32 indexed _last); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct Extension { - #[allow(missing_docs)] - pub _first: alloy::sol_types::private::FixedBytes<32>, - #[allow(missing_docs)] - pub _last: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for Extension { - type DataTuple<'a> = (); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - const SIGNATURE: &'static str = "Extension(bytes32,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 249u8, 14u8, 79u8, 29u8, 156u8, 208u8, 221u8, 85u8, 227u8, 57u8, 65u8, - 28u8, 188u8, 155u8, 21u8, 36u8, 130u8, 48u8, 124u8, 58u8, 35u8, 237u8, - 100u8, 113u8, 94u8, 74u8, 40u8, 88u8, 246u8, 65u8, 163u8, 245u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - _first: topics.1, - _last: topics.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return 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) -> ::RustType { - (Self::SIGNATURE_HASH.into(), self._first.clone(), self._last.clone()) - } - #[inline] - fn encode_topics_raw( - &self, - out: &mut [alloy_sol_types::abi::token::WordToken], - ) -> alloy_sol_types::Result<()> { - if out.len() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self._first); - out[2usize] = as alloy_sol_types::EventTopic>::encode_topic(&self._last); - Ok(()) - } - } - #[automatically_derived] - impl alloy_sol_types::private::IntoLogData for Extension { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&Extension> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &Extension) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. -```solidity -event log(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolConstructor for constructorCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getBlockHeights(string,uint256,uint256)` and selector `0xfad06b8f`. -```solidity -function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getBlockHeightsCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getBlockHeights(string,uint256,uint256)`](getBlockHeightsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getBlockHeightsReturn { - #[allow(missing_docs)] - pub elements: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getBlockHeightsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - #[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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getBlockHeightsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getBlockHeightsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getBlockHeights(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [250u8, 208u8, 107u8, 143u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getDigestLes(string,uint256,uint256)` and selector `0x44badbb6`. -```solidity -function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getDigestLesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getDigestLes(string,uint256,uint256)`](getDigestLesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getDigestLesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getDigestLesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getDigestLesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getDigestLesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array< - alloy::sol_types::sol_data::FixedBytes<32>, - >, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getDigestLes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [68u8, 186u8, 219u8, 182u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaderHexes(string,uint256,uint256)` and selector `0x0813852a`. -```solidity -function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaderHexes(string,uint256,uint256)`](getHeaderHexesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeaderHexesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getHeaderHexesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getHeaderHexesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Bytes, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaderHexes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [8u8, 19u8, 133u8, 42u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaders(string,uint256,uint256)` and selector `0x1c0da81f`. -```solidity -function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaders(string,uint256,uint256)`](getHeadersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersReturn { - #[allow(missing_docs)] - pub headers: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersReturn) -> Self { - (value.headers,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { headers: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getHeadersCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Bytes; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaders(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [28u8, 13u8, 168u8, 31u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testExtensionEventFiring()` and selector `0xdc30f7d1`. -```solidity -function testExtensionEventFiring() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testExtensionEventFiringCall; - ///Container type for the return parameters of the [`testExtensionEventFiring()`](testExtensionEventFiringCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testExtensionEventFiringReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testExtensionEventFiringCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testExtensionEventFiringCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testExtensionEventFiringReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testExtensionEventFiringReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testExtensionEventFiringReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testExtensionEventFiringCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testExtensionEventFiringReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testExtensionEventFiring()"; - const SELECTOR: [u8; 4] = [220u8, 48u8, 247u8, 209u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testExtensionEventFiringReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testExternalRetarget()` and selector `0x7ac31f58`. -```solidity -function testExternalRetarget() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testExternalRetargetCall; - ///Container type for the return parameters of the [`testExternalRetarget()`](testExternalRetargetCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testExternalRetargetReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testExternalRetargetCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testExternalRetargetCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testExternalRetargetReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testExternalRetargetReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testExternalRetargetReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testExternalRetargetCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testExternalRetargetReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testExternalRetarget()"; - const SELECTOR: [u8; 4] = [122u8, 195u8, 31u8, 88u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testExternalRetargetReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testIInsufficientWork()` and selector `0x9bfc927a`. -```solidity -function testIInsufficientWork() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIInsufficientWorkCall; - ///Container type for the return parameters of the [`testIInsufficientWork()`](testIInsufficientWorkCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIInsufficientWorkReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIInsufficientWorkCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIInsufficientWorkCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIInsufficientWorkReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIInsufficientWorkReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testIInsufficientWorkReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testIInsufficientWorkCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testIInsufficientWorkReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testIInsufficientWork()"; - const SELECTOR: [u8; 4] = [155u8, 252u8, 146u8, 122u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testIInsufficientWorkReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testIncorrectAnchorLength()` and selector `0x2f45b065`. -```solidity -function testIncorrectAnchorLength() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIncorrectAnchorLengthCall; - ///Container type for the return parameters of the [`testIncorrectAnchorLength()`](testIncorrectAnchorLengthCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIncorrectAnchorLengthReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIncorrectAnchorLengthCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIncorrectAnchorLengthCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIncorrectAnchorLengthReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIncorrectAnchorLengthReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testIncorrectAnchorLengthReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testIncorrectAnchorLengthCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testIncorrectAnchorLengthReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testIncorrectAnchorLength()"; - const SELECTOR: [u8; 4] = [47u8, 69u8, 176u8, 101u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testIncorrectAnchorLengthReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testIncorrectHeaderChainLength()` and selector `0x9adc0a0f`. -```solidity -function testIncorrectHeaderChainLength() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIncorrectHeaderChainLengthCall; - ///Container type for the return parameters of the [`testIncorrectHeaderChainLength()`](testIncorrectHeaderChainLengthCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIncorrectHeaderChainLengthReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIncorrectHeaderChainLengthCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIncorrectHeaderChainLengthCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIncorrectHeaderChainLengthReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIncorrectHeaderChainLengthReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testIncorrectHeaderChainLengthReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testIncorrectHeaderChainLengthCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testIncorrectHeaderChainLengthReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testIncorrectHeaderChainLength()"; - const SELECTOR: [u8; 4] = [154u8, 220u8, 10u8, 15u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testIncorrectHeaderChainLengthReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testTargetCangesMidchain()` and selector `0xa1473fa7`. -```solidity -function testTargetCangesMidchain() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testTargetCangesMidchainCall; - ///Container type for the return parameters of the [`testTargetCangesMidchain()`](testTargetCangesMidchainCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testTargetCangesMidchainReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testTargetCangesMidchainCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testTargetCangesMidchainCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testTargetCangesMidchainReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testTargetCangesMidchainReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testTargetCangesMidchainReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testTargetCangesMidchainCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testTargetCangesMidchainReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testTargetCangesMidchain()"; - const SELECTOR: [u8; 4] = [161u8, 71u8, 63u8, 167u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testTargetCangesMidchainReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`FullRelayAddHeaderTest`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum FullRelayAddHeaderTestCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - getBlockHeights(getBlockHeightsCall), - #[allow(missing_docs)] - getDigestLes(getDigestLesCall), - #[allow(missing_docs)] - getHeaderHexes(getHeaderHexesCall), - #[allow(missing_docs)] - getHeaders(getHeadersCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - testExtensionEventFiring(testExtensionEventFiringCall), - #[allow(missing_docs)] - testExternalRetarget(testExternalRetargetCall), - #[allow(missing_docs)] - testIInsufficientWork(testIInsufficientWorkCall), - #[allow(missing_docs)] - testIncorrectAnchorLength(testIncorrectAnchorLengthCall), - #[allow(missing_docs)] - testIncorrectHeaderChainLength(testIncorrectHeaderChainLengthCall), - #[allow(missing_docs)] - testTargetCangesMidchain(testTargetCangesMidchainCall), - } - #[automatically_derived] - impl FullRelayAddHeaderTestCalls { - /// 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, 19u8, 133u8, 42u8], - [28u8, 13u8, 168u8, 31u8], - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [47u8, 69u8, 176u8, 101u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [68u8, 186u8, 219u8, 182u8], - [102u8, 217u8, 169u8, 160u8], - [122u8, 195u8, 31u8, 88u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [154u8, 220u8, 10u8, 15u8], - [155u8, 252u8, 146u8, 122u8], - [161u8, 71u8, 63u8, 167u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [220u8, 48u8, 247u8, 209u8], - [226u8, 12u8, 159u8, 113u8], - [250u8, 118u8, 38u8, 212u8], - [250u8, 208u8, 107u8, 143u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for FullRelayAddHeaderTestCalls { - const NAME: &'static str = "FullRelayAddHeaderTestCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 22usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::getBlockHeights(_) => { - ::SELECTOR - } - Self::getDigestLes(_) => { - ::SELECTOR - } - Self::getHeaderHexes(_) => { - ::SELECTOR - } - Self::getHeaders(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::testExtensionEventFiring(_) => { - ::SELECTOR - } - Self::testExternalRetarget(_) => { - ::SELECTOR - } - Self::testIInsufficientWork(_) => { - ::SELECTOR - } - Self::testIncorrectAnchorLength(_) => { - ::SELECTOR - } - Self::testIncorrectHeaderChainLength(_) => { - ::SELECTOR - } - Self::testTargetCangesMidchain(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderTestCalls::getHeaderHexes) - } - getHeaderHexes - }, - { - fn getHeaders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderTestCalls::getHeaders) - } - getHeaders - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderTestCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderTestCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn testIncorrectAnchorLength( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderTestCalls::testIncorrectAnchorLength) - } - testIncorrectAnchorLength - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderTestCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderTestCalls::targetContracts) - } - targetContracts - }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderTestCalls::getDigestLes) - } - getDigestLes - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderTestCalls::targetArtifactSelectors) - } - targetArtifactSelectors - }, - { - fn testExternalRetarget( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderTestCalls::testExternalRetarget) - } - testExternalRetarget - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderTestCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderTestCalls::targetSelectors) - } - targetSelectors - }, - { - fn testIncorrectHeaderChainLength( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - FullRelayAddHeaderTestCalls::testIncorrectHeaderChainLength, - ) - } - testIncorrectHeaderChainLength - }, - { - fn testIInsufficientWork( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderTestCalls::testIInsufficientWork) - } - testIInsufficientWork - }, - { - fn testTargetCangesMidchain( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderTestCalls::testTargetCangesMidchain) - } - testTargetCangesMidchain - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderTestCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderTestCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(FullRelayAddHeaderTestCalls::failed) - } - failed - }, - { - fn testExtensionEventFiring( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderTestCalls::testExtensionEventFiring) - } - testExtensionEventFiring - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderTestCalls::excludeContracts) - } - excludeContracts - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(FullRelayAddHeaderTestCalls::IS_TEST) - } - IS_TEST - }, - { - fn getBlockHeights( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderTestCalls::getBlockHeights) - } - getBlockHeights - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderTestCalls::getHeaderHexes) - } - getHeaderHexes - }, - { - fn getHeaders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderTestCalls::getHeaders) - } - getHeaders - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderTestCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderTestCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn testIncorrectAnchorLength( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderTestCalls::testIncorrectAnchorLength) - } - testIncorrectAnchorLength - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderTestCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderTestCalls::targetContracts) - } - targetContracts - }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderTestCalls::getDigestLes) - } - getDigestLes - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderTestCalls::targetArtifactSelectors) - } - targetArtifactSelectors - }, - { - fn testExternalRetarget( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderTestCalls::testExternalRetarget) - } - testExternalRetarget - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderTestCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderTestCalls::targetSelectors) - } - targetSelectors - }, - { - fn testIncorrectHeaderChainLength( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayAddHeaderTestCalls::testIncorrectHeaderChainLength, - ) - } - testIncorrectHeaderChainLength - }, - { - fn testIInsufficientWork( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderTestCalls::testIInsufficientWork) - } - testIInsufficientWork - }, - { - fn testTargetCangesMidchain( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderTestCalls::testTargetCangesMidchain) - } - testTargetCangesMidchain - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderTestCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderTestCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderTestCalls::failed) - } - failed - }, - { - fn testExtensionEventFiring( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderTestCalls::testExtensionEventFiring) - } - testExtensionEventFiring - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderTestCalls::excludeContracts) - } - excludeContracts - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderTestCalls::IS_TEST) - } - IS_TEST - }, - { - fn getBlockHeights( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderTestCalls::getBlockHeights) - } - getBlockHeights - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::getBlockHeights(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getDigestLes(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getHeaders(inner) => { - ::abi_encoded_size(inner) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testExtensionEventFiring(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testExternalRetarget(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testIInsufficientWork(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testIncorrectAnchorLength(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testIncorrectHeaderChainLength(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testTargetCangesMidchain(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::getBlockHeights(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getDigestLes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testExtensionEventFiring(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testExternalRetarget(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testIInsufficientWork(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testIncorrectAnchorLength(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testIncorrectHeaderChainLength(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testTargetCangesMidchain(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`FullRelayAddHeaderTest`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum FullRelayAddHeaderTestEvents { - #[allow(missing_docs)] - Extension(Extension), - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl FullRelayAddHeaderTestEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 249u8, 14u8, 79u8, 29u8, 156u8, 208u8, 221u8, 85u8, 227u8, 57u8, 65u8, - 28u8, 188u8, 155u8, 21u8, 36u8, 130u8, 48u8, 124u8, 58u8, 35u8, 237u8, - 100u8, 113u8, 94u8, 74u8, 40u8, 88u8, 246u8, 65u8, 163u8, 245u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for FullRelayAddHeaderTestEvents { - const NAME: &'static str = "FullRelayAddHeaderTestEvents"; - const COUNT: usize = 23usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::Extension) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 FullRelayAddHeaderTestEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::Extension(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::Extension(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`FullRelayAddHeaderTest`](self) contract instance. - -See the [wrapper's documentation](`FullRelayAddHeaderTestInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> FullRelayAddHeaderTestInstance { - FullRelayAddHeaderTestInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - FullRelayAddHeaderTestInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - FullRelayAddHeaderTestInstance::::deploy_builder(provider) - } - /**A [`FullRelayAddHeaderTest`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`FullRelayAddHeaderTest`](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 FullRelayAddHeaderTestInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for FullRelayAddHeaderTestInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("FullRelayAddHeaderTestInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayAddHeaderTestInstance { - /**Creates a new wrapper around an on-chain [`FullRelayAddHeaderTest`](self) contract instance. - -See the [wrapper's documentation](`FullRelayAddHeaderTestInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 FullRelayAddHeaderTestInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> FullRelayAddHeaderTestInstance { - FullRelayAddHeaderTestInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayAddHeaderTestInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`getBlockHeights`] function. - pub fn getBlockHeights( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getBlockHeightsCall, N> { - self.call_builder( - &getBlockHeightsCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getDigestLes`] function. - pub fn getDigestLes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getDigestLesCall, N> { - self.call_builder( - &getDigestLesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaderHexes`] function. - pub fn getHeaderHexes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeaderHexesCall, N> { - self.call_builder( - &getHeaderHexesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaders`] function. - pub fn getHeaders( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeadersCall, N> { - self.call_builder( - &getHeadersCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`testExtensionEventFiring`] function. - pub fn testExtensionEventFiring( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testExtensionEventFiringCall, N> { - self.call_builder(&testExtensionEventFiringCall) - } - ///Creates a new call builder for the [`testExternalRetarget`] function. - pub fn testExternalRetarget( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testExternalRetargetCall, N> { - self.call_builder(&testExternalRetargetCall) - } - ///Creates a new call builder for the [`testIInsufficientWork`] function. - pub fn testIInsufficientWork( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testIInsufficientWorkCall, N> { - self.call_builder(&testIInsufficientWorkCall) - } - ///Creates a new call builder for the [`testIncorrectAnchorLength`] function. - pub fn testIncorrectAnchorLength( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testIncorrectAnchorLengthCall, N> { - self.call_builder(&testIncorrectAnchorLengthCall) - } - ///Creates a new call builder for the [`testIncorrectHeaderChainLength`] function. - pub fn testIncorrectHeaderChainLength( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testIncorrectHeaderChainLengthCall, N> { - self.call_builder(&testIncorrectHeaderChainLengthCall) - } - ///Creates a new call builder for the [`testTargetCangesMidchain`] function. - pub fn testTargetCangesMidchain( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testTargetCangesMidchainCall, N> { - self.call_builder(&testTargetCangesMidchainCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayAddHeaderTestInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`Extension`] event. - pub fn Extension_filter(&self) -> alloy_contract::Event<&P, Extension, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/fullrelayaddheaderwithretargettest.rs b/crates/bindings/src/fullrelayaddheaderwithretargettest.rs deleted file mode 100644 index db1bcda3b..000000000 --- a/crates/bindings/src/fullrelayaddheaderwithretargettest.rs +++ /dev/null @@ -1,9635 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface FullRelayAddHeaderWithRetargetTest { - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - constructor(); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); - function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); - function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); - function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function testAppendsNewLinksToTheChain() external; - function testOldPeriodEndHeaderUnknown() external; - function testOldPeriodEndMismatch() external; - function testOldPeriodStartHeaderUnknown() external; - function testOldPeriodStartToEndNot2015Blocks() external; - function testRetargetPerformedIncorrectly() external; -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getBlockHeights", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getDigestLes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes32[]", - "internalType": "bytes32[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaderHexes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes[]", - "internalType": "bytes[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaders", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "headers", - "type": "bytes", - "internalType": "bytes" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testAppendsNewLinksToTheChain", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testOldPeriodEndHeaderUnknown", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testOldPeriodEndMismatch", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testOldPeriodStartHeaderUnknown", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testOldPeriodStartToEndNot2015Blocks", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testRetargetPerformedIncorrectly", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 FullRelayAddHeaderWithRetargetTest { - use super::*; - use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15a\0,W__\xFD[P`@Q\x80`@\x01`@R\x80`\x18\x81R` \x01\x7FheadersWithRetarget.json\0\0\0\0\0\0\0\0\x81RP`@Q\x80`@\x01`@R\x80`\r\x81R` \x01l\x05\xCCm\x0C--\xCBf+\xA5\xCD\x0C\xAF`\x9B\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x10\x81R` \x01o\x0B\x98\xDA\x18Z[\x96\xCCWK\x9A\x19ZY\xDA\x1D`\x82\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x19\x81R` \x01\x7F.oldPeriodStart.digest_le\0\0\0\0\0\0\0\x81RP__Q` a\x863_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x16c\xD90\xA0\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x011W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01X\x91\x90\x81\x01\x90a\n\xABV[\x90P_\x81\x86`@Q` \x01a\x01n\x92\x91\x90a\x0B\x06V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Rc`\xF9\xBB\x11`\xE0\x1B\x82R\x91P_Q` a\x863_9_Q\x90_R\x90c`\xF9\xBB\x11\x90a\x01\xAE\x90\x84\x90`\x04\x01a\x0BxV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xC8W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01\xEF\x91\x90\x81\x01\x90a\n\xABV[` \x90a\x01\xFC\x90\x82a\x0C\x0EV[Pa\x02\x93\x85` \x80Ta\x02\x0E\x90a\x0B\x8AV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02:\x90a\x0B\x8AV[\x80\x15a\x02\x85W\x80`\x1F\x10a\x02\\Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02\x85V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02hW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x06t\x91PPV[a\x03)\x85` \x80Ta\x02\xA4\x90a\x0B\x8AV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\xD0\x90a\x0B\x8AV[\x80\x15a\x03\x1BW\x80`\x1F\x10a\x02\xF2Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\x1BV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02\xFEW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x06\xF3\x91PPV[a\x03\xBF\x85` \x80Ta\x03:\x90a\x0B\x8AV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03f\x90a\x0B\x8AV[\x80\x15a\x03\xB1W\x80`\x1F\x10a\x03\x88Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xB1V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\x94W\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x07f\x91PPV[`@Qa\x03\xCB\x90a\n\x15V[a\x03\xD7\x93\x92\x91\x90a\x0C\xC8V[`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03\xF0W=__>=_\xFD[P`\x1F`\x01a\x01\0\n\x81T\x81`\x01`\x01`\xA0\x1B\x03\x02\x19\x16\x90\x83`\x01`\x01`\xA0\x1B\x03\x16\x02\x17\x90UPPPPPPPa\x04M`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01d1\xB40\xB4\xB7`\xD9\x1B\x81RP`\x02`\ta\x07\x9A` \x1B` \x1CV[`\"\x90a\x04Z\x90\x82a\x0C\x0EV[P`@\x80Q\x80\x82\x01\x90\x91R`\x05\x81Rd1\xB40\xB4\xB7`\xD9\x1B` \x82\x01Ra\x04\x84\x90`\t`\x0Fa\x07\x9AV[`!\x90a\x04\x91\x90\x82a\x0C\x0EV[Pa\x04\xC8`@Q\x80`@\x01`@R\x80`\r\x81R` \x01l\x05\xCCm\x0C--\xCBf+\xA5\xCD\x0C\xAF`\x9B\x1B\x81RP` \x80Ta\x02\x0E\x90a\x0B\x8AV[`'\x90a\x04\xD5\x90\x82a\x0C\x0EV[Pa\x05\x1C`@Q\x80`@\x01`@R\x80`\x13\x81R` \x01\x7F.oldPeriodStart.hex\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x80Ta\x02\x0E\x90a\x0B\x8AV[`#\x90a\x05)\x90\x82a\x0C\x0EV[Pa\x05p`@Q\x80`@\x01`@R\x80`\x19\x81R` \x01\x7F.oldPeriodStart.digest_le\0\0\0\0\0\0\0\x81RP` \x80Ta\x03:\x90a\x0B\x8AV[`$\x81\x90UPa\x05\xAC`@Q\x80`@\x01`@R\x80`\r\x81R` \x01l\x05\xCCm\x0C--\xCBg\x0B\xA5\xCD\x0C\xAF`\x9B\x1B\x81RP` \x80Ta\x02\x0E\x90a\x0B\x8AV[`%\x90a\x05\xB9\x90\x82a\x0C\x0EV[Pa\x05\xF3`@Q\x80`@\x01`@R\x80`\x10\x81R` \x01o\x0B\x98\xDA\x18Z[\x96\xCE\x17K\x9A\x19ZY\xDA\x1D`\x82\x1B\x81RP` \x80Ta\x02\xA4\x90a\x0B\x8AV[`&U`\x1FT`@Qce\xDAA\xB9`\xE0\x1B\x81Ra\x01\0\x90\x91\x04`\x01`\x01`\xA0\x1B\x03\x16\x90ce\xDAA\xB9\x90a\x06.\x90`'\x90`\"\x90`\x04\x01a\rkV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x06JW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06n\x91\x90a\r\x8FV[Pa\x0E\xEEV[`@Qc\x1F\xB2C}`\xE3\x1B\x81R``\x90_Q` a\x863_9_Q\x90_R\x90c\xFD\x92\x1B\xE8\x90a\x06\xA9\x90\x86\x90\x86\x90`\x04\x01a\r\xB5V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xC3W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x06\xEA\x91\x90\x81\x01\x90a\n\xABV[\x90P[\x92\x91PPV[`@QcV\xEE\xF1[`\xE1\x1B\x81R_\x90_Q` a\x863_9_Q\x90_R\x90c\xAD\xDD\xE2\xB6\x90a\x07'\x90\x86\x90\x86\x90`\x04\x01a\r\xB5V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07BW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xEA\x91\x90a\r\xD9V[`@Qc\x17w\xE5\x9D`\xE0\x1B\x81R_\x90_Q` a\x863_9_Q\x90_R\x90c\x17w\xE5\x9D\x90a\x07'\x90\x86\x90\x86\x90`\x04\x01a\r\xB5V[``_a\x07\xA8\x85\x85\x85a\x08\x0CV[\x90P_[a\x07\xB6\x85\x85a\x0E\x04V[\x81\x10\x15a\x08\x03W\x82\x82\x82\x81Q\x81\x10a\x07\xD0Wa\x07\xD0a\x0E\x17V[` \x02` \x01\x01Q`@Q` \x01a\x07\xE9\x92\x91\x90a\x0E+V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x07\xACV[PP\x93\x92PPPV[``a\x08;\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01b\r\x0C\xAF`\xEB\x1B\x81RPa\x08C` \x1B` \x1CV[\x94\x93PPPPV[``a\x08O\x84\x84a\x0E\x04V[`\x01`\x01`@\x1B\x03\x81\x11\x15a\x08fWa\x08fa\n\"V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x08\x99W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x08\x84W\x90P[P\x90P\x83[\x83\x81\x10\x15a\t\x10Wa\x08\xE2\x86a\x08\xB3\x83a\t\x19V[\x85`@Q` \x01a\x08\xC6\x93\x92\x91\x90a\x0E?V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x02\x0E\x90a\x0B\x8AV[\x82a\x08\xED\x87\x84a\x0E\x04V[\x81Q\x81\x10a\x08\xFDWa\x08\xFDa\x0E\x17V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x08\x9EV[P\x94\x93PPPPV[``\x81_\x03a\t?WPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R`\x03`\xFC\x1B` \x82\x01R\x90V[\x81_[\x81\x15a\thW\x80a\tR\x81a\x0E\x89V[\x91Pa\ta\x90P`\n\x83a\x0E\xB5V[\x91Pa\tBV[_\x81`\x01`\x01`@\x1B\x03\x81\x11\x15a\t\x81Wa\t\x81a\n\"V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\t\xABW` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x08;Wa\t\xC0`\x01\x83a\x0E\x04V[\x91Pa\t\xCD`\n\x86a\x0E\xC8V[a\t\xD8\x90`0a\x0E\xDBV[`\xF8\x1B\x81\x83\x81Q\x81\x10a\t\xEDWa\t\xEDa\x0E\x17V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SPa\n\x0E`\n\x86a\x0E\xB5V[\x94Pa\t\xAFV[a);\x80a\\\xF8\x839\x01\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x80`\x01`\x01`@\x1B\x03\x84\x11\x15a\nOWa\nOa\n\"V[P`@Q`\x1F\x19`\x1F\x85\x01\x81\x16`?\x01\x16\x81\x01\x81\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17\x15a\n}Wa\n}a\n\"V[`@R\x83\x81R\x90P\x80\x82\x84\x01\x85\x10\x15a\n\x94W__\xFD[\x83\x83` \x83\x01^_` \x85\x83\x01\x01RP\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\n\xBBW__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\n\xD0W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\n\xE0W__\xFD[a\x08;\x84\x82Q` \x84\x01a\n6V[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x0B\x11\x82\x85a\n\xEFV[\x7F/test/fullRelay/testData/\0\0\0\0\0\0\0\x81Ra\x0BA`\x19\x82\x01\x85a\n\xEFV[\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R_a\x06\xEA` \x83\x01\x84a\x0BJV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x0B\x9EW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x0B\xBCWcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\x0C\tW\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x0B\xE7WP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x0C\x06W_\x81U`\x01\x01a\x0B\xF3V[PP[PPPV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x0C'Wa\x0C'a\n\"V[a\x0C;\x81a\x0C5\x84Ta\x0B\x8AV[\x84a\x0B\xC2V[` `\x1F\x82\x11`\x01\x81\x14a\x0CmW_\x83\x15a\x0CVWP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x0C\x06V[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x0C\x9CW\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x0C|V[P\x84\x82\x10\x15a\x0C\xB9W\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[``\x81R_a\x0C\xDA``\x83\x01\x86a\x0BJV[` \x83\x01\x94\x90\x94RP`@\x01R\x91\x90PV[_\x81Ta\x0C\xF8\x81a\x0B\x8AV[\x80\x85R`\x01\x82\x16\x80\x15a\r\x12W`\x01\x81\x14a\r.Wa\rbV[`\xFF\x19\x83\x16` \x87\x01R` \x82\x15\x15`\x05\x1B\x87\x01\x01\x93Pa\rbV[\x84_R` _ _[\x83\x81\x10\x15a\rYW\x81T` \x82\x8A\x01\x01R`\x01\x82\x01\x91P` \x81\x01\x90Pa\r7V[\x87\x01` \x01\x94PP[PPP\x92\x91PPV[`@\x81R_a\r}`@\x83\x01\x85a\x0C\xECV[\x82\x81\x03` \x84\x01Ra\x0BA\x81\x85a\x0C\xECV[_` \x82\x84\x03\x12\x15a\r\x9FW__\xFD[\x81Q\x80\x15\x15\x81\x14a\r\xAEW__\xFD[\x93\x92PPPV[`@\x81R_a\r\xC7`@\x83\x01\x85a\x0BJV[\x82\x81\x03` \x84\x01Ra\x0BA\x81\x85a\x0BJV[_` \x82\x84\x03\x12\x15a\r\xE9W__\xFD[PQ\x91\x90PV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x06\xEDWa\x06\xEDa\r\xF0V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[_a\x08;a\x0E9\x83\x86a\n\xEFV[\x84a\n\xEFV[`\x17`\xF9\x1B\x81R_a\x0ET`\x01\x83\x01\x86a\n\xEFV[`[`\xF8\x1B\x81Ra\x0Eh`\x01\x82\x01\x86a\n\xEFV[\x90Pa.\x97`\xF1\x1B\x81Ra\x0E\x7F`\x02\x82\x01\x85a\n\xEFV[\x96\x95PPPPPPV[_`\x01\x82\x01a\x0E\x9AWa\x0E\x9Aa\r\xF0V[P`\x01\x01\x90V[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x0E\xC3Wa\x0E\xC3a\x0E\xA1V[P\x04\x90V[_\x82a\x0E\xD6Wa\x0E\xD6a\x0E\xA1V[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a\x06\xEDWa\x06\xEDa\r\xF0V[aM\xFD\x80a\x0E\xFB_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01yW_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\xD2W\x80c\xE2\x0C\x9Fq\x11a\0\x88W\x80c\xFAv&\xD4\x11a\0cW\x80c\xFAv&\xD4\x14a\x02\xB9W\x80c\xFA\xD0k\x8F\x14a\x02\xC6W\x80c\xFD\xD9\x8E\x03\x14a\x02\xD9W__\xFD[\x80c\xE2\x0C\x9Fq\x14a\x02\xA1W\x80c\xE8\xC7\x05\xC8\x14a\x02\xA9W\x80c\xEEv\x18\x12\x14a\x02\xB1W__\xFD[\x80c\xB5P\x8A\xA9\x11a\0\xB8W\x80c\xB5P\x8A\xA9\x14a\x02yW\x80c\xBAAO\xA6\x14a\x02\x81W\x80c\xC0c\"\xC3\x14a\x02\x99W__\xFD[\x80c\x91j\x17\xC6\x14a\x02\\W\x80c\xB0FO\xDC\x14a\x02qW__\xFD[\x80c*\xDE8\x80\x11a\x012W\x80cD\xBA\xDB\xB6\x11a\x01\rW\x80cD\xBA\xDB\xB6\x14a\x02\x12W\x80cf\xD9\xA9\xA0\x14a\x022W\x80c\x85\"l\x81\x14a\x02GW__\xFD[\x80c*\xDE8\x80\x14a\x01\xEDW\x80c>^<#\x14a\x02\x02W\x80c?r\x86\xF4\x14a\x02\nW__\xFD[\x80c\x1C\r\xA8\x1F\x11a\x01bW\x80c\x1C\r\xA8\x1F\x14a\x01\xB0W\x80c\x1E\xD7\x83\x1C\x14a\x01\xD0W\x80c&\n@\xD8\x14a\x01\xE5W__\xFD[\x80c\x08\x13\x85*\x14a\x01}W\x80c\nb\x0F\x07\x14a\x01\xA6W[__\xFD[a\x01\x90a\x01\x8B6`\x04a\x1B\xCCV[a\x02\xE1V[`@Qa\x01\x9D\x91\x90a\x1C\x81V[`@Q\x80\x91\x03\x90\xF3[a\x01\xAEa\x03,V[\0[a\x01\xC3a\x01\xBE6`\x04a\x1B\xCCV[a\x04_V[`@Qa\x01\x9D\x91\x90a\x1C\xE4V[a\x01\xD8a\x04\xD1V[`@Qa\x01\x9D\x91\x90a\x1C\xF6V[a\x01\xAEa\x05>V[a\x01\xF5a\x07hV[`@Qa\x01\x9D\x91\x90a\x1D\xA8V[a\x01\xD8a\x08\xB1V[a\x01\xD8a\t\x1CV[a\x02%a\x02 6`\x04a\x1B\xCCV[a\t\x87V[`@Qa\x01\x9D\x91\x90a\x1E,V[a\x02:a\t\xCAV[`@Qa\x01\x9D\x91\x90a\x1E\xBFV[a\x02Oa\x0BCV[`@Qa\x01\x9D\x91\x90a\x1F=V[a\x02da\x0C\x0EV[`@Qa\x01\x9D\x91\x90a\x1FOV[a\x02da\r\x11V[a\x02Oa\x0E\x14V[a\x02\x89a\x0E\xDFV[`@Q\x90\x15\x15\x81R` \x01a\x01\x9DV[a\x01\xAEa\x0F\xAFV[a\x01\xD8a\x10\xA1V[a\x01\xAEa\x11\x0CV[a\x01\xAEa\x12\xA0V[`\x1FTa\x02\x89\x90`\xFF\x16\x81V[a\x02%a\x02\xD46`\x04a\x1B\xCCV[a\x13\x92V[a\x01\xAEa\x13\xD5V[``a\x03$\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x15\xB3V[\x94\x93PPPPV[sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xF2\x8D\xCE\xB3`@Q\x80``\x01`@R\x80`.\x81R` \x01aM\x9A`.\x919`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x03\x91\x91\x90a\x1C\xE4V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x03\xA8W__\xFD[PZ\xF1\x15\x80\x15a\x03\xBAW=__>=_\xFD[PP`\x1FT`@Q\x7F\x7F\xA67\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\x81Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92Pc\x7F\xA67\xFC\x91Pa\x04\x1C\x90`%\x90`!\x90`\x04\x01a \xC7V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x048W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04\\\x91\x90a!\x08V[PV[``_a\x04m\x85\x85\x85a\x02\xE1V[\x90P_[a\x04{\x85\x85a!BV[\x81\x10\x15a\x04\xC8W\x82\x82\x82\x81Q\x81\x10a\x04\x95Wa\x04\x95a!UV[` \x02` \x01\x01Q`@Q` \x01a\x04\xAE\x92\x91\x90a!\x80V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x04qV[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x054W` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x05\tW[PPPPP\x90P\x90V[`\x1FT`@Q\x7F\x7F\xA67\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\x81Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90c\x7F\xA67\xFC\x90a\x05\x9F\x90`#\x90`%\x90`!\x90`\x04\x01a!\x94V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x05\xBBW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xDF\x91\x90a!\x08V[P`&Ta\x05\xEE\x90`\x02a!\xD6V[`\x1F`\x01\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`\xB5\xC3\x90a\x06\xFC`@Q\x80`@\x01`@R\x80`\x14\x81R` \x01\x7F.chain[10].digest_le\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x80Ta\x06r\x90a\x1F\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06\x9E\x90a\x1F\xD3V[\x80\x15a\x06\xE9W\x80`\x1F\x10a\x06\xC0Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x06\xE9V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x06\xCCW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x16\x8A\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x07\x1A\x91\x81R` \x01\x90V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x075W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07Y\x91\x90a!\xE9V[\x14a\x07fWa\x07fa\"\0V[V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xA8W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x08\x91W\x83\x82\x90_R` _ \x01\x80Ta\x08\x06\x90a\x1F\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x082\x90a\x1F\xD3V[\x80\x15a\x08}W\x80`\x1F\x10a\x08TWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x08}V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x08`W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x07\xE9V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07\x8BV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x054W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x05\tWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x054W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x05\tWPPPPP\x90P\x90V[``a\x03$\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x17&V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xA8W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\n\x1D\x90a\x1F\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\nI\x90a\x1F\xD3V[\x80\x15a\n\x94W\x80`\x1F\x10a\nkWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\x94V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\nwW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x0B+W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\n\xD8W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\t\xEDV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xA8W\x83\x82\x90_R` _ \x01\x80Ta\x0B\x83\x90a\x1F\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\xAF\x90a\x1F\xD3V[\x80\x15a\x0B\xFAW\x80`\x1F\x10a\x0B\xD1Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\xFAV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xDDW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0BfV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xA8W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\xF9W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C\xA6W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0C1V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xA8W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\xFCW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\xA9W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\r4V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xA8W\x83\x82\x90_R` _ \x01\x80Ta\x0ET\x90a\x1F\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0E\x80\x90a\x1F\xD3V[\x80\x15a\x0E\xCBW\x80`\x1F\x10a\x0E\xA2Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0E\xCBV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0E\xAEW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0E7V[`\x08T_\x90`\xFF\x16\x15a\x0E\xF6WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\x84W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xA8\x91\x90a!\xE9V[\x14\x15\x90P\x90V[sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xF2\x8D\xCE\xB3`@Q\x80``\x01`@R\x80`(\x81R` \x01aM5`(\x919`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x10\x14\x91\x90a\x1C\xE4V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10+W__\xFD[PZ\xF1\x15\x80\x15a\x10=W=__>=_\xFD[PP`\x1FT`@Q\x7F\x7F\xA67\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\x81Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92Pc\x7F\xA67\xFC\x91Pa\x04\x1C\x90`%\x90\x81\x90`!\x90`\x04\x01a!\x94V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x054W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x05\tWPPPPP\x90P\x90V[`'`&T`$T`@Qa\x11 \x90a\x1BSV[a\x11,\x93\x92\x91\x90a\"\x14V[`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x11EW=__>=_\xFD[P`\x1F\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\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\x90U`@\x80Q\x80\x82\x01\x82R`\x19\x81R\x7FInvalid retarget provided\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x12\x12\x91\x90`\x04\x01a\x1C\xE4V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12)W__\xFD[PZ\xF1\x15\x80\x15a\x12;W=__>=_\xFD[PP`\x1FT`@Q\x7F\x7F\xA67\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\x81Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92Pc\x7F\xA67\xFC\x91Pa\x04\x1C\x90`#\x90`'\x90`!\x90`\x04\x01a!\x94V[sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xF2\x8D\xCE\xB3`@Q\x80``\x01`@R\x80`=\x81R` \x01aM]`=\x919`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x13\x05\x91\x90a\x1C\xE4V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x13\x1CW__\xFD[PZ\xF1\x15\x80\x15a\x13.W=__>=_\xFD[PP`\x1FT`@Q\x7F\x7F\xA67\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\x81Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92Pc\x7F\xA67\xFC\x91Pa\x04\x1C\x90`#\x90\x81\x90`!\x90`\x04\x01a!\x94V[``a\x03$\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x17\xEAV[`@\x80Q\x80\x82\x01\x82R`\r\x81R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x14V\x91\x90`\x04\x01a\x1C\xE4V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x14mW__\xFD[PZ\xF1\x15\x80\x15a\x14\x7FW=__>=_\xFD[PPPP`\x1F`\x01\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\x7F\xA67\xFC`#a\x15\x93`@Q\x80`@\x01`@R\x80`\x0E\x81R` \x01\x7F.chain[15].hex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x80Ta\x15\t\x90a\x1F\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x155\x90a\x1F\xD3V[\x80\x15a\x15\x80W\x80`\x1F\x10a\x15WWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x15\x80V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15cW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x198\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[`!`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x04\x1C\x93\x92\x91\x90a\"8V[``a\x15\xBF\x84\x84a!BV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x15\xD7Wa\x15\xD7a\x1B`V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x16\nW\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x15\xF5W\x90P[P\x90P\x83[\x83\x81\x10\x15a\x16\x81Wa\x16S\x86a\x16$\x83a\x19\xCEV[\x85`@Q` \x01a\x167\x93\x92\x91\x90a\"\\V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x15\t\x90a\x1F\xD3V[\x82a\x16^\x87\x84a!BV[\x81Q\x81\x10a\x16nWa\x16na!UV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x16\x0FV[P\x94\x93PPPPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x16\xDE\x90\x86\x90\x86\x90`\x04\x01a\"\xEFV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x16\xF9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x17\x1D\x91\x90a!\xE9V[\x90P[\x92\x91PPV[``a\x172\x84\x84a!BV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17JWa\x17Ja\x1B`V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x17sW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x16\x81Wa\x17\xBC\x86a\x17\x8D\x83a\x19\xCEV[\x85`@Q` \x01a\x17\xA0\x93\x92\x91\x90a\"\\V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x06r\x90a\x1F\xD3V[\x82a\x17\xC7\x87\x84a!BV[\x81Q\x81\x10a\x17\xD7Wa\x17\xD7a!UV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x17xV[``a\x17\xF6\x84\x84a!BV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\x0EWa\x18\x0Ea\x1B`V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x187W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x16\x81Wa\x19\n\x86a\x18Q\x83a\x19\xCEV[\x85`@Q` \x01a\x18d\x93\x92\x91\x90a\"\\V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x18\x80\x90a\x1F\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x18\xAC\x90a\x1F\xD3V[\x80\x15a\x18\xF7W\x80`\x1F\x10a\x18\xCEWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x18\xF7V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x18\xDAW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x1A\xFF\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x19\x15\x87\x84a!BV[\x81Q\x81\x10a\x19%Wa\x19%a!UV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x18=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x17\x1D\x91\x90\x81\x01\x90a#\x13V[``\x81_\x03a\x1A\x10WPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x1A9W\x80a\x1A#\x81a#\x88V[\x91Pa\x1A2\x90P`\n\x83a#\xD3V[\x91Pa\x1A\x13V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1ASWa\x1ASa\x1B`V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x1A}W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x03$Wa\x1A\x92`\x01\x83a!BV[\x91Pa\x1A\x9F`\n\x86a#\xE6V[a\x1A\xAA\x90`0a!\xD6V[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x1A\xBFWa\x1A\xBFa!UV[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x1A\xF8`\n\x86a#\xD3V[\x94Pa\x1A\x81V[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x16\xDE\x90\x86\x90\x86\x90`\x04\x01a\"\xEFV[a);\x80a#\xFA\x839\x01\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x1B\x9DWa\x1B\x9Da\x1B`V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x1B\xBEWa\x1B\xBEa\x1B`V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x1B\xDEW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1B\xF4W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x1C\x04W__\xFD[\x805a\x1C\x17a\x1C\x12\x82a\x1B\xA5V[a\x1BtV[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x1C+W__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1C\xD8W`?\x19\x87\x86\x03\x01\x84Ra\x1C\xC3\x85\x83Qa\x1CSV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1C\xA7V[P\x92\x96\x95PPPPPPV[` \x81R_a\x17\x1D` \x83\x01\x84a\x1CSV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1DCW\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\x1D\x0FV[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x1D\x9CW`\x1F\x19\x85\x84\x03\x01\x88Ra\x1D\x86\x83\x83Qa\x1CSV[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x1DjV[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1C\xD8W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1E\x16`@\x87\x01\x82a\x1DNV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1D\xCEV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1DCW\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1EEV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x1E\xB5W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x1EuV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1C\xD8W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x1F\x0B`@\x88\x01\x82a\x1CSV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x1F&\x81\x83a\x1EcV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1E\xE5V[` \x81R_a\x17\x1D` \x83\x01\x84a\x1DNV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1C\xD8W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1F\xBD`@\x87\x01\x82a\x1EcV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1FuV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1F\xE7W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a \x05WcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[\x80T_\x90`\x01\x81\x81\x1C\x90\x82\x16\x80a #W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a AWcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[\x81\x86R` \x86\x01\x81\x80\x15a \\W`\x01\x81\x14a \x90Wa \xBCV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x85\x16\x82R\x83\x15\x15`\x05\x1B\x82\x01\x95Pa \xBCV[_\x87\x81R` \x90 _[\x85\x81\x10\x15a \xB6W\x81T\x84\x82\x01R`\x01\x90\x91\x01\x90` \x01a \x9AV[\x83\x01\x96PP[PPPPP\x92\x91PPV[``\x81R`\x01``\x82\x01R_`\x80\x82\x01R`\xA0` \x82\x01R_a \xED`\xA0\x83\x01\x85a \x0BV[\x82\x81\x03`@\x84\x01Ra \xFF\x81\x85a \x0BV[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a!\x18W__\xFD[\x81Q\x80\x15\x15\x81\x14a!'W__\xFD[\x93\x92PPPV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x17 Wa\x17 a!.V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x03$a!\x8E\x83\x86a!iV[\x84a!iV[``\x81R_a!\xA6``\x83\x01\x86a \x0BV[\x82\x81\x03` \x84\x01Ra!\xB8\x81\x86a \x0BV[\x90P\x82\x81\x03`@\x84\x01Ra!\xCC\x81\x85a \x0BV[\x96\x95PPPPPPV[\x80\x82\x01\x80\x82\x11\x15a\x17 Wa\x17 a!.V[_` \x82\x84\x03\x12\x15a!\xF9W__\xFD[PQ\x91\x90PV[cNH{q`\xE0\x1B_R`\x01`\x04R`$_\xFD[``\x81R_a\"&``\x83\x01\x86a \x0BV[` \x83\x01\x94\x90\x94RP`@\x01R\x91\x90PV[``\x81R_a\"J``\x83\x01\x86a \x0BV[\x82\x81\x03` \x84\x01Ra!\xB8\x81\x86a\x1CSV[\x7F.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R_a\"\x8D`\x01\x83\x01\x86a!iV[\x7F[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\"\xBD`\x01\x82\x01\x86a!iV[\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\x81Ra!\xCC`\x02\x82\x01\x85a!iV[`@\x81R_a#\x01`@\x83\x01\x85a\x1CSV[\x82\x81\x03` \x84\x01Ra \xFF\x81\x85a\x1CSV[_` \x82\x84\x03\x12\x15a##W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a#9W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a#IW__\xFD[\x80Qa#Wa\x1C\x12\x82a\x1B\xA5V[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a#kW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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#\xB8Wa#\xB8a!.V[P`\x01\x01\x90V[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a#\xE1Wa#\xE1a#\xBFV[P\x04\x90V[_\x82a#\xF4Wa#\xF4a#\xBFV[P\x06\x90V\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa);8\x03\x80a);\x839\x81\x01`@\x81\x90Ra\0.\x91a\x03+V[\x82\x82\x82\x82\x82\x82a\0?\x83Q`P\x14\x90V[a\0\x84W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x11`$\x82\x01RpBad genesis block`x\x1B`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\0\x8E\x84a\x01fV[\x90Pb\xFF\xFF\xFF\x82\x16\x15a\x01\tW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FPeriod start hash does not have `D\x82\x01R\x7Fwork. Hint: wrong byte order?\0\0\0`d\x82\x01R`\x84\x01a\0{V[_\x81\x81U`\x01\x82\x90U`\x02\x82\x90U\x81\x81R`\x04` R`@\x90 \x83\x90Ua\x012a\x07\xE0\x84a\x03\xFEV[a\x01<\x90\x84a\x04%V[_\x83\x81R`\x04` R`@\x90 Ua\x01S\x84a\x02&V[`\x05UPa\x05\xBD\x98PPPPPPPPPV[_`\x02\x80\x83`@Qa\x01x\x91\x90a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\x93W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x04NV[`@Q` \x01a\x01\xC8\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x01\xE2\x91a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\xFDW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02 \x91\x90a\x04NV[\x92\x91PPV[_a\x02 a\x023\x83a\x028V[a\x02CV[_a\x02 \x82\x82a\x02SV[_a\x02 a\xFF\xFF`\xD0\x1B\x83a\x02\xF7V[_\x80a\x02ja\x02c\x84`Ha\x04eV[\x85\x90a\x03\tV[`\xE8\x1C\x90P_\x84a\x02|\x85`Ka\x04eV[\x81Q\x81\x10a\x02\x8CWa\x02\x8Ca\x04xV[\x01` \x01Q`\xF8\x1C\x90P_a\x02\xBE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x02\xD1`\x03\x84a\x04\x8CV[`\xFF\x16\x90Pa\x02\xE2\x81a\x01\0a\x05\x88V[a\x02\xEC\x90\x83a\x05\x93V[\x97\x96PPPPPPPV[_a\x03\x02\x82\x84a\x05\xAAV[\x93\x92PPPV[_a\x03\x02\x83\x83\x01` \x01Q\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x03=W__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03RW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03bW__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03{Wa\x03{a\x03\x17V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x03\xA9Wa\x03\xA9a\x03\x17V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x03\xC0W__\xFD[\x81` \x84\x01` \x83\x01^_` \x92\x82\x01\x83\x01R\x90\x86\x01Q`@\x90\x96\x01Q\x90\x97\x95\x96P\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x04\x0CWa\x04\x0Ca\x03\xEAV[P\x06\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x04^W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02 Wa\x02 a\x04\x11V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[`\x01\x81[`\x01\x84\x11\x15a\x04\xE0W\x80\x85\x04\x81\x11\x15a\x04\xC4Wa\x04\xC4a\x04\x11V[`\x01\x84\x16\x15a\x04\xD2W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x04\xA9V[\x93P\x93\x91PPV[_\x82a\x04\xF6WP`\x01a\x02 V[\x81a\x05\x02WP_a\x02 V[\x81`\x01\x81\x14a\x05\x18W`\x02\x81\x14a\x05\"Wa\x05>V[`\x01\x91PPa\x02 V[`\xFF\x84\x11\x15a\x053Wa\x053a\x04\x11V[PP`\x01\x82\x1Ba\x02 V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x05aWP\x81\x81\na\x02 V[a\x05m_\x19\x84\x84a\x04\xA5V[\x80_\x19\x04\x82\x11\x15a\x05\x80Wa\x05\x80a\x04\x11V[\x02\x93\x92PPPV[_a\x03\x02\x83\x83a\x04\xE8V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x02 Wa\x02 a\x04\x11V[_\x82a\x05\xB8Wa\x05\xB8a\x03\xEAV[P\x04\x90V[a#q\x80a\x05\xCA_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\xADW\x80c\xB9\x85b\x1A\x11a\0}W\x80c\xE3\xD8\xD8\xD8\x11a\0cW\x80c\xE3\xD8\xD8\xD8\x14a\x02\"W\x80c\xE4q\xE7,\x14a\x02)W\x80c\xF5\x8D\xB0o\x14a\x02=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x13\x91\x90a!WV[`@Q` \x01a\x0C%\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\x90\x82\x90Ra\x0C]\x91a!AV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0CxW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x07\x91\x90a!WV[_\x83\x85\x14\x80\x15a\x0C\xAAWP\x82\x85\x14[\x15a\x0C\xB7WP`\x01a\x04\xF1V[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x0C\xFFW\x89\x83\x14a\x0C\xDEW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x0C\xF7W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x0C\xBDV[P\x82\x84\x03a\r\x13W_\x94PPPPPa\x04\xF1V[\x80\x82\x14a\r&W_\x94PPPPPa\x04\xF1V[P`\x01\x98\x97PPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\rYW_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\r9V[P\x80a\x05\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x80\x82\x81[a\r\xB8`\x04`\x01a!\x9BV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0E\x0CW_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\r\xF1W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0E\x04V[a\r\xFB\x81\x84a!\xB7V[\x95\x94PPPPPV[`\x01\x01a\r\xACV[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_`P\x82Qa\x0B~\x91\x90a!.V[__a\x0Eo\x85a\x0B\xC3V[\x90P_a\x0E{\x82a\r\xA7V[\x90P_a\x0E\x87\x86a\x19\xE6V[\x90P\x84\x80a\x0E\x9CWP\x80a\x0E\x9A\x88a\x19\xE6V[\x14[a\x0F\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x03.V[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x12\x0EWa\x0F(`P\x82a!\xCAV[a\x0F3\x90`\x01a!\xB7V[a\x0F=\x90\x87a!\xB7V[\x93Pa\x0FK\x8A\x82`Pa\x19\xF1V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x11!W\x84a\x10\xA1\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x10\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x11\n`\x04\x85a!.V[_\x03a\x11!W_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x11,\x8B\x83a\x1A\x16V[\x14a\x11yW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[\x86a\x11\x84\x8B\x83a\x1A\xAFV[\x14a\x11\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x03.V[\x82\x96P`P\x81a\x12\x07\x91\x90a!\xB7V[\x90Pa\x0F\x15V[P\x81a\x12\x19\x8Ba\x0B\xC3V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x12\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x12\xD4\x84a\x0B\xC3V[\x90P_a\x12\xE0\x86a\x0B\xC3V[\x90P`\x01T\x81\x14a\x133W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x03.V[_\x82\x81R`\x03` R`@\x90 Ta\x13\x8DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x13\x9B\x87`\x01T\x84\x87a\x0C\x9BV[a\x14\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x03.V[\x81a\x14\x19\x88\x88\x88a\x17\x80V[\x14a\x14\x8CW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[`\x01\x82\x90U`\x02\x87\x90U_a\x14\xA0\x86a\x1A\xC7V[\x90P`\x05T\x81\x14a\x14\xB1W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x15\x01a\x14\xFC\x86a\x0B\xC3V[a\r\xA7V[\x90P_a\x15\x10a\x14\xFC\x86a\x0B\xC3V[\x90Pa\x15\x1Ea\x07\xE0\x82a!.V[a\x07\xDF\x14a\x15\x94W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x03.V[a\x15\xA0\x82a\x07\xDFa!\xB7V[\x81\x14a\x16\x14W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x03.V[a\x16\x1D\x85a\x1A\xC7V[a\x16&\x87a\x1A\xC7V[\x14a\x16\x99W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x03.V[_a\x16\xA3\x85a\x19\xE6V[\x90P_a\x16\xD5a\x16\xB2\x89a\x19\xE6V[a\x16\xBB\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x16\xCA\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x1B\x0CV[\x90P\x81\x81\x83\x16\x14a\x17(W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_a\x172\x89a\x1A\xC7V[\x90P\x80`\x06T\x14\x15\x80\x15a\x17\\WPa\x07\xE0a\x17O`\x01Ta\r\xA7V[a\x17Y\x91\x90a!\xDDV[\x84\x11[\x15a\x17gW`\x06\x81\x90U[a\x17s\x88\x88`\x01a\x0EdV[\x99\x98PPPPPPPPPV[__a\x17\x8B\x85a\r\xA7V[\x90P_a\x17\x9Aa\x14\xFC\x86a\x0B\xC3V[\x90P_a\x17\xA9a\x14\xFC\x86a\x0B\xC3V[\x90P\x82\x82\x10\x15\x80\x15a\x17\xBBWP\x82\x81\x10\x15[a\x18-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x18:a\x07\xE0\x85a!.V[a\x18F\x85a\x07\xE0a!\xB7V[a\x18P\x91\x90a!\xDDV[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x18bWP\x80[\x15a\x18}Wa\x18p\x89a\x0B\xC3V[\x96PPPPPPPa\n\xA3V[\x81\x80\x15a\x18\x88WP\x80\x15[\x15a\x18\x96Wa\x18p\x88a\x0B\xC3V[\x81\x80\x15a\x18\xA0WP\x80[\x15a\x18\xC4W\x83\x85\x10\x15a\x18\xBBWa\x18\xB6\x88a\x0B\xC3V[a\x18pV[a\x18p\x89a\x0B\xC3V[a\x18\xCD\x88a\x1A\xC7V[a\x18\xD9a\x07\xE0\x86a!.V[a\x18\xE3\x91\x90a!\xF0V[a\x18\xEC\x8Aa\x1A\xC7V[a\x18\xF8a\x07\xE0\x88a!.V[a\x19\x02\x91\x90a!\xF0V[\x10\x15a\x18\xBBWa\x18p\x88a\x0B\xC3V[`\x07T_\x90`\xFF\x16\x15a\x19/WP`\x07Ta\x01\0\x90\x04`\xFF\x16a\n\xA3V[a\x19:\x84\x84\x84a\x1B\x94V[\x90Pa\n\xA3V[_` \x84Qa\x19P\x91\x90a!.V[\x15a\x19\\WP_a\x04\xF1V[\x83Q_\x03a\x19kWP_a\x04\xF1V[\x81\x85_[\x86Q\x81\x10\x15a\x19\xD9Wa\x19\x83`\x02\x84a!.V[`\x01\x03a\x19\xA7Wa\x19\xA0a\x19\x9A\x88\x83\x01` \x01Q\x90V[\x83a\x1B\xD5V[\x91Pa\x19\xC0V[a\x19\xBD\x82a\x19\xB8\x89\x84\x01` \x01Q\x90V[a\x1B\xD5V[\x91P[`\x01\x92\x90\x92\x1C\x91a\x19\xD2` \x82a!\xB7V[\x90Pa\x19oV[P\x90\x93\x14\x95\x94PPPPPV[_a\x05\x07\x82_a\x1A\x16V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x1A-a\x1A&\x84`Ha!\xB7V[\x85\x90a\x1B\xE0V[`\xE8\x1C\x90P_\x84a\x1A?\x85`Ka!\xB7V[\x81Q\x81\x10a\x1AOWa\x1AOa\"\x07V[\x01` \x01Q`\xF8\x1C\x90P_a\x1A\x81\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1A\x94`\x03\x84a\"4V[`\xFF\x16\x90Pa\x1A\xA5\x81a\x01\0a#0V[a\x08-\x90\x83a!\xF0V[_a\x05\x04a\x1A\xBE\x83`\x04a!\xB7V[\x84\x01` \x01Q\x90V[_a\x05\x07a\x1A\xD4\x83a\x19\xE6V[a\x1B\xEEV[_a\x05\x07a\x1A\xE6\x83a\x1C\x15V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1B\x18\x83\x85a\x1C!V[\x90Pa\x1B(b\x12u\0`\x04a\x1C|V[\x81\x10\x15a\x1B@Wa\x1B=b\x12u\0`\x04a\x1C|V[\x90P[a\x1BNb\x12u\0`\x04a\x1C\x87V[\x81\x11\x15a\x1BfWa\x1Bcb\x12u\0`\x04a\x1C\x87V[\x90P[_a\x1B~\x82a\x1Bx\x88b\x01\0\0a\x1C|V[\x90a\x1C\x87V[\x90Pa\n\x8Ab\x01\0\0a\x1Bx\x83b\x12u\0a\x1C|V[_\x82\x81[\x83\x81\x10\x15a\x1B\xCAW\x85\x82\x03a\x1B\xB2W`\x01\x92PPPa\n\xA3V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x1B\x98V[P_\x95\x94PPPPPV[_a\x05\x04\x83\x83a\x1C\xFAV[_a\x05\x04\x83\x83\x01` \x01Q\x90V[_a\x05\x07{\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\x83a\x1C|V[_a\x05\x07\x82`Da\x1B\xE0V[_\x82\x82\x11\x15a\x1CrW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x05\x04\x82\x84a!\xDDV[_a\x05\x04\x82\x84a!\xCAV[_\x82_\x03a\x1C\x96WP_a\x05\x07V[a\x1C\xA0\x82\x84a!\xF0V[\x90P\x81a\x1C\xAD\x84\x83a!\xCAV[\x14a\x05\x07W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x03.V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1D1W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DHW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1D_W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1DvW__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1D\x91W__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xA7W__\xFD[a\x1D\xB3\x8A\x82\x8B\x01a\x1D!V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xD2W__\xFD[a\x1D\xDE\x8A\x82\x8B\x01a\x1D!V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1D\xFE`\x80\x89\x01a\x1DfV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[____`\x80\x85\x87\x03\x12\x15a\x1E\x1FW__\xFD[PP\x825\x94` \x84\x015\x94P`@\x84\x015\x93``\x015\x92P\x90PV[__`@\x83\x85\x03\x12\x15a\x1ELW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1EkW__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1E\x85W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x9BW__\xFD[a\x1E\xA7\x87\x82\x88\x01a\x1D!V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\xC6W__\xFD[a\x1E\xD2\x87\x82\x88\x01a\x1D!V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1E\xF3W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x10W__\xFD[a\x1F\x1C\x89\x82\x8A\x01a\x1D!V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F;W__\xFD[a\x1FG\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1FtW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x8AW__\xFD[a\x1F\x96\x89\x82\x8A\x01a\x1D!V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xB5W__\xFD[a\x1F\xC1\x89\x82\x8A\x01a\x1D!V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xE0W__\xFD[a\x1F\xEC\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_____``\x86\x88\x03\x12\x15a \x12W__\xFD[\x855\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a /W__\xFD[a ;\x88\x82\x89\x01a\x1D!V[\x90\x95P\x93PP`@\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a ZW__\xFD[a f\x88\x82\x89\x01a\x1D!V[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[___``\x84\x86\x03\x12\x15a \x89W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a \xB1W__\xFD[\x825\x91Pa \xC1` \x84\x01a\x1DfV[\x90P\x92P\x92\x90PV[\x805\x80\x15\x15\x81\x14a\x1DvW__\xFD[__`@\x83\x85\x03\x12\x15a \xEAW__\xFD[a \xF3\x83a \xCAV[\x91Pa \xC1` \x84\x01a \xCAV[\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!=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x04NV[`@Q` \x01a\x01\xC8\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x01\xE2\x91a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\xFDW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02 \x91\x90a\x04NV[\x92\x91PPV[_a\x02 a\x023\x83a\x028V[a\x02CV[_a\x02 \x82\x82a\x02SV[_a\x02 a\xFF\xFF`\xD0\x1B\x83a\x02\xF7V[_\x80a\x02ja\x02c\x84`Ha\x04eV[\x85\x90a\x03\tV[`\xE8\x1C\x90P_\x84a\x02|\x85`Ka\x04eV[\x81Q\x81\x10a\x02\x8CWa\x02\x8Ca\x04xV[\x01` \x01Q`\xF8\x1C\x90P_a\x02\xBE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x02\xD1`\x03\x84a\x04\x8CV[`\xFF\x16\x90Pa\x02\xE2\x81a\x01\0a\x05\x88V[a\x02\xEC\x90\x83a\x05\x93V[\x97\x96PPPPPPPV[_a\x03\x02\x82\x84a\x05\xAAV[\x93\x92PPPV[_a\x03\x02\x83\x83\x01` \x01Q\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x03=W__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03RW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03bW__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03{Wa\x03{a\x03\x17V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x03\xA9Wa\x03\xA9a\x03\x17V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x03\xC0W__\xFD[\x81` \x84\x01` \x83\x01^_` \x92\x82\x01\x83\x01R\x90\x86\x01Q`@\x90\x96\x01Q\x90\x97\x95\x96P\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x04\x0CWa\x04\x0Ca\x03\xEAV[P\x06\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x04^W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02 Wa\x02 a\x04\x11V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[`\x01\x81[`\x01\x84\x11\x15a\x04\xE0W\x80\x85\x04\x81\x11\x15a\x04\xC4Wa\x04\xC4a\x04\x11V[`\x01\x84\x16\x15a\x04\xD2W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x04\xA9V[\x93P\x93\x91PPV[_\x82a\x04\xF6WP`\x01a\x02 V[\x81a\x05\x02WP_a\x02 V[\x81`\x01\x81\x14a\x05\x18W`\x02\x81\x14a\x05\"Wa\x05>V[`\x01\x91PPa\x02 V[`\xFF\x84\x11\x15a\x053Wa\x053a\x04\x11V[PP`\x01\x82\x1Ba\x02 V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x05aWP\x81\x81\na\x02 V[a\x05m_\x19\x84\x84a\x04\xA5V[\x80_\x19\x04\x82\x11\x15a\x05\x80Wa\x05\x80a\x04\x11V[\x02\x93\x92PPPV[_a\x03\x02\x83\x83a\x04\xE8V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x02 Wa\x02 a\x04\x11V[_\x82a\x05\xB8Wa\x05\xB8a\x03\xEAV[P\x04\x90V[a#q\x80a\x05\xCA_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\xADW\x80c\xB9\x85b\x1A\x11a\0}W\x80c\xE3\xD8\xD8\xD8\x11a\0cW\x80c\xE3\xD8\xD8\xD8\x14a\x02\"W\x80c\xE4q\xE7,\x14a\x02)W\x80c\xF5\x8D\xB0o\x14a\x02=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x13\x91\x90a!WV[`@Q` \x01a\x0C%\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\x90\x82\x90Ra\x0C]\x91a!AV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0CxW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x07\x91\x90a!WV[_\x83\x85\x14\x80\x15a\x0C\xAAWP\x82\x85\x14[\x15a\x0C\xB7WP`\x01a\x04\xF1V[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x0C\xFFW\x89\x83\x14a\x0C\xDEW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x0C\xF7W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x0C\xBDV[P\x82\x84\x03a\r\x13W_\x94PPPPPa\x04\xF1V[\x80\x82\x14a\r&W_\x94PPPPPa\x04\xF1V[P`\x01\x98\x97PPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\rYW_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\r9V[P\x80a\x05\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x80\x82\x81[a\r\xB8`\x04`\x01a!\x9BV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0E\x0CW_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\r\xF1W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0E\x04V[a\r\xFB\x81\x84a!\xB7V[\x95\x94PPPPPV[`\x01\x01a\r\xACV[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_`P\x82Qa\x0B~\x91\x90a!.V[__a\x0Eo\x85a\x0B\xC3V[\x90P_a\x0E{\x82a\r\xA7V[\x90P_a\x0E\x87\x86a\x19\xE6V[\x90P\x84\x80a\x0E\x9CWP\x80a\x0E\x9A\x88a\x19\xE6V[\x14[a\x0F\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x03.V[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x12\x0EWa\x0F(`P\x82a!\xCAV[a\x0F3\x90`\x01a!\xB7V[a\x0F=\x90\x87a!\xB7V[\x93Pa\x0FK\x8A\x82`Pa\x19\xF1V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x11!W\x84a\x10\xA1\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x10\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x11\n`\x04\x85a!.V[_\x03a\x11!W_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x11,\x8B\x83a\x1A\x16V[\x14a\x11yW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[\x86a\x11\x84\x8B\x83a\x1A\xAFV[\x14a\x11\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x03.V[\x82\x96P`P\x81a\x12\x07\x91\x90a!\xB7V[\x90Pa\x0F\x15V[P\x81a\x12\x19\x8Ba\x0B\xC3V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x12\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x12\xD4\x84a\x0B\xC3V[\x90P_a\x12\xE0\x86a\x0B\xC3V[\x90P`\x01T\x81\x14a\x133W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x03.V[_\x82\x81R`\x03` R`@\x90 Ta\x13\x8DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x13\x9B\x87`\x01T\x84\x87a\x0C\x9BV[a\x14\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x03.V[\x81a\x14\x19\x88\x88\x88a\x17\x80V[\x14a\x14\x8CW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[`\x01\x82\x90U`\x02\x87\x90U_a\x14\xA0\x86a\x1A\xC7V[\x90P`\x05T\x81\x14a\x14\xB1W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x15\x01a\x14\xFC\x86a\x0B\xC3V[a\r\xA7V[\x90P_a\x15\x10a\x14\xFC\x86a\x0B\xC3V[\x90Pa\x15\x1Ea\x07\xE0\x82a!.V[a\x07\xDF\x14a\x15\x94W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x03.V[a\x15\xA0\x82a\x07\xDFa!\xB7V[\x81\x14a\x16\x14W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x03.V[a\x16\x1D\x85a\x1A\xC7V[a\x16&\x87a\x1A\xC7V[\x14a\x16\x99W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x03.V[_a\x16\xA3\x85a\x19\xE6V[\x90P_a\x16\xD5a\x16\xB2\x89a\x19\xE6V[a\x16\xBB\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x16\xCA\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x1B\x0CV[\x90P\x81\x81\x83\x16\x14a\x17(W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_a\x172\x89a\x1A\xC7V[\x90P\x80`\x06T\x14\x15\x80\x15a\x17\\WPa\x07\xE0a\x17O`\x01Ta\r\xA7V[a\x17Y\x91\x90a!\xDDV[\x84\x11[\x15a\x17gW`\x06\x81\x90U[a\x17s\x88\x88`\x01a\x0EdV[\x99\x98PPPPPPPPPV[__a\x17\x8B\x85a\r\xA7V[\x90P_a\x17\x9Aa\x14\xFC\x86a\x0B\xC3V[\x90P_a\x17\xA9a\x14\xFC\x86a\x0B\xC3V[\x90P\x82\x82\x10\x15\x80\x15a\x17\xBBWP\x82\x81\x10\x15[a\x18-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x18:a\x07\xE0\x85a!.V[a\x18F\x85a\x07\xE0a!\xB7V[a\x18P\x91\x90a!\xDDV[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x18bWP\x80[\x15a\x18}Wa\x18p\x89a\x0B\xC3V[\x96PPPPPPPa\n\xA3V[\x81\x80\x15a\x18\x88WP\x80\x15[\x15a\x18\x96Wa\x18p\x88a\x0B\xC3V[\x81\x80\x15a\x18\xA0WP\x80[\x15a\x18\xC4W\x83\x85\x10\x15a\x18\xBBWa\x18\xB6\x88a\x0B\xC3V[a\x18pV[a\x18p\x89a\x0B\xC3V[a\x18\xCD\x88a\x1A\xC7V[a\x18\xD9a\x07\xE0\x86a!.V[a\x18\xE3\x91\x90a!\xF0V[a\x18\xEC\x8Aa\x1A\xC7V[a\x18\xF8a\x07\xE0\x88a!.V[a\x19\x02\x91\x90a!\xF0V[\x10\x15a\x18\xBBWa\x18p\x88a\x0B\xC3V[`\x07T_\x90`\xFF\x16\x15a\x19/WP`\x07Ta\x01\0\x90\x04`\xFF\x16a\n\xA3V[a\x19:\x84\x84\x84a\x1B\x94V[\x90Pa\n\xA3V[_` \x84Qa\x19P\x91\x90a!.V[\x15a\x19\\WP_a\x04\xF1V[\x83Q_\x03a\x19kWP_a\x04\xF1V[\x81\x85_[\x86Q\x81\x10\x15a\x19\xD9Wa\x19\x83`\x02\x84a!.V[`\x01\x03a\x19\xA7Wa\x19\xA0a\x19\x9A\x88\x83\x01` \x01Q\x90V[\x83a\x1B\xD5V[\x91Pa\x19\xC0V[a\x19\xBD\x82a\x19\xB8\x89\x84\x01` \x01Q\x90V[a\x1B\xD5V[\x91P[`\x01\x92\x90\x92\x1C\x91a\x19\xD2` \x82a!\xB7V[\x90Pa\x19oV[P\x90\x93\x14\x95\x94PPPPPV[_a\x05\x07\x82_a\x1A\x16V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x1A-a\x1A&\x84`Ha!\xB7V[\x85\x90a\x1B\xE0V[`\xE8\x1C\x90P_\x84a\x1A?\x85`Ka!\xB7V[\x81Q\x81\x10a\x1AOWa\x1AOa\"\x07V[\x01` \x01Q`\xF8\x1C\x90P_a\x1A\x81\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1A\x94`\x03\x84a\"4V[`\xFF\x16\x90Pa\x1A\xA5\x81a\x01\0a#0V[a\x08-\x90\x83a!\xF0V[_a\x05\x04a\x1A\xBE\x83`\x04a!\xB7V[\x84\x01` \x01Q\x90V[_a\x05\x07a\x1A\xD4\x83a\x19\xE6V[a\x1B\xEEV[_a\x05\x07a\x1A\xE6\x83a\x1C\x15V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1B\x18\x83\x85a\x1C!V[\x90Pa\x1B(b\x12u\0`\x04a\x1C|V[\x81\x10\x15a\x1B@Wa\x1B=b\x12u\0`\x04a\x1C|V[\x90P[a\x1BNb\x12u\0`\x04a\x1C\x87V[\x81\x11\x15a\x1BfWa\x1Bcb\x12u\0`\x04a\x1C\x87V[\x90P[_a\x1B~\x82a\x1Bx\x88b\x01\0\0a\x1C|V[\x90a\x1C\x87V[\x90Pa\n\x8Ab\x01\0\0a\x1Bx\x83b\x12u\0a\x1C|V[_\x82\x81[\x83\x81\x10\x15a\x1B\xCAW\x85\x82\x03a\x1B\xB2W`\x01\x92PPPa\n\xA3V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x1B\x98V[P_\x95\x94PPPPPV[_a\x05\x04\x83\x83a\x1C\xFAV[_a\x05\x04\x83\x83\x01` \x01Q\x90V[_a\x05\x07{\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\x83a\x1C|V[_a\x05\x07\x82`Da\x1B\xE0V[_\x82\x82\x11\x15a\x1CrW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x05\x04\x82\x84a!\xDDV[_a\x05\x04\x82\x84a!\xCAV[_\x82_\x03a\x1C\x96WP_a\x05\x07V[a\x1C\xA0\x82\x84a!\xF0V[\x90P\x81a\x1C\xAD\x84\x83a!\xCAV[\x14a\x05\x07W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x03.V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1D1W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DHW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1D_W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1DvW__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1D\x91W__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xA7W__\xFD[a\x1D\xB3\x8A\x82\x8B\x01a\x1D!V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xD2W__\xFD[a\x1D\xDE\x8A\x82\x8B\x01a\x1D!V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1D\xFE`\x80\x89\x01a\x1DfV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[____`\x80\x85\x87\x03\x12\x15a\x1E\x1FW__\xFD[PP\x825\x94` \x84\x015\x94P`@\x84\x015\x93``\x015\x92P\x90PV[__`@\x83\x85\x03\x12\x15a\x1ELW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1EkW__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1E\x85W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x9BW__\xFD[a\x1E\xA7\x87\x82\x88\x01a\x1D!V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\xC6W__\xFD[a\x1E\xD2\x87\x82\x88\x01a\x1D!V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1E\xF3W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x10W__\xFD[a\x1F\x1C\x89\x82\x8A\x01a\x1D!V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F;W__\xFD[a\x1FG\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1FtW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x8AW__\xFD[a\x1F\x96\x89\x82\x8A\x01a\x1D!V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xB5W__\xFD[a\x1F\xC1\x89\x82\x8A\x01a\x1D!V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xE0W__\xFD[a\x1F\xEC\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_____``\x86\x88\x03\x12\x15a \x12W__\xFD[\x855\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a /W__\xFD[a ;\x88\x82\x89\x01a\x1D!V[\x90\x95P\x93PP`@\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a ZW__\xFD[a f\x88\x82\x89\x01a\x1D!V[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[___``\x84\x86\x03\x12\x15a \x89W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a \xB1W__\xFD[\x825\x91Pa \xC1` \x84\x01a\x1DfV[\x90P\x92P\x92\x90PV[\x805\x80\x15\x15\x81\x14a\x1DvW__\xFD[__`@\x83\x85\x03\x12\x15a \xEAW__\xFD[a \xF3\x83a \xCAV[\x91Pa \xC1` \x84\x01a \xCAV[\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!^<#\x14a\x02\x02W\x80c?r\x86\xF4\x14a\x02\nW__\xFD[\x80c\x1C\r\xA8\x1F\x11a\x01bW\x80c\x1C\r\xA8\x1F\x14a\x01\xB0W\x80c\x1E\xD7\x83\x1C\x14a\x01\xD0W\x80c&\n@\xD8\x14a\x01\xE5W__\xFD[\x80c\x08\x13\x85*\x14a\x01}W\x80c\nb\x0F\x07\x14a\x01\xA6W[__\xFD[a\x01\x90a\x01\x8B6`\x04a\x1B\xCCV[a\x02\xE1V[`@Qa\x01\x9D\x91\x90a\x1C\x81V[`@Q\x80\x91\x03\x90\xF3[a\x01\xAEa\x03,V[\0[a\x01\xC3a\x01\xBE6`\x04a\x1B\xCCV[a\x04_V[`@Qa\x01\x9D\x91\x90a\x1C\xE4V[a\x01\xD8a\x04\xD1V[`@Qa\x01\x9D\x91\x90a\x1C\xF6V[a\x01\xAEa\x05>V[a\x01\xF5a\x07hV[`@Qa\x01\x9D\x91\x90a\x1D\xA8V[a\x01\xD8a\x08\xB1V[a\x01\xD8a\t\x1CV[a\x02%a\x02 6`\x04a\x1B\xCCV[a\t\x87V[`@Qa\x01\x9D\x91\x90a\x1E,V[a\x02:a\t\xCAV[`@Qa\x01\x9D\x91\x90a\x1E\xBFV[a\x02Oa\x0BCV[`@Qa\x01\x9D\x91\x90a\x1F=V[a\x02da\x0C\x0EV[`@Qa\x01\x9D\x91\x90a\x1FOV[a\x02da\r\x11V[a\x02Oa\x0E\x14V[a\x02\x89a\x0E\xDFV[`@Q\x90\x15\x15\x81R` \x01a\x01\x9DV[a\x01\xAEa\x0F\xAFV[a\x01\xD8a\x10\xA1V[a\x01\xAEa\x11\x0CV[a\x01\xAEa\x12\xA0V[`\x1FTa\x02\x89\x90`\xFF\x16\x81V[a\x02%a\x02\xD46`\x04a\x1B\xCCV[a\x13\x92V[a\x01\xAEa\x13\xD5V[``a\x03$\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x15\xB3V[\x94\x93PPPPV[sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xF2\x8D\xCE\xB3`@Q\x80``\x01`@R\x80`.\x81R` \x01aM\x9A`.\x919`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x03\x91\x91\x90a\x1C\xE4V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x03\xA8W__\xFD[PZ\xF1\x15\x80\x15a\x03\xBAW=__>=_\xFD[PP`\x1FT`@Q\x7F\x7F\xA67\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\x81Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92Pc\x7F\xA67\xFC\x91Pa\x04\x1C\x90`%\x90`!\x90`\x04\x01a \xC7V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x048W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04\\\x91\x90a!\x08V[PV[``_a\x04m\x85\x85\x85a\x02\xE1V[\x90P_[a\x04{\x85\x85a!BV[\x81\x10\x15a\x04\xC8W\x82\x82\x82\x81Q\x81\x10a\x04\x95Wa\x04\x95a!UV[` \x02` \x01\x01Q`@Q` \x01a\x04\xAE\x92\x91\x90a!\x80V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x04qV[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x054W` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x05\tW[PPPPP\x90P\x90V[`\x1FT`@Q\x7F\x7F\xA67\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\x81Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90c\x7F\xA67\xFC\x90a\x05\x9F\x90`#\x90`%\x90`!\x90`\x04\x01a!\x94V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x05\xBBW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xDF\x91\x90a!\x08V[P`&Ta\x05\xEE\x90`\x02a!\xD6V[`\x1F`\x01\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`\xB5\xC3\x90a\x06\xFC`@Q\x80`@\x01`@R\x80`\x14\x81R` \x01\x7F.chain[10].digest_le\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x80Ta\x06r\x90a\x1F\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06\x9E\x90a\x1F\xD3V[\x80\x15a\x06\xE9W\x80`\x1F\x10a\x06\xC0Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x06\xE9V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x06\xCCW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x16\x8A\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x07\x1A\x91\x81R` \x01\x90V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x075W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07Y\x91\x90a!\xE9V[\x14a\x07fWa\x07fa\"\0V[V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xA8W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x08\x91W\x83\x82\x90_R` _ \x01\x80Ta\x08\x06\x90a\x1F\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x082\x90a\x1F\xD3V[\x80\x15a\x08}W\x80`\x1F\x10a\x08TWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x08}V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x08`W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x07\xE9V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07\x8BV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x054W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x05\tWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x054W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x05\tWPPPPP\x90P\x90V[``a\x03$\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x17&V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xA8W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\n\x1D\x90a\x1F\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\nI\x90a\x1F\xD3V[\x80\x15a\n\x94W\x80`\x1F\x10a\nkWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\x94V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\nwW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x0B+W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\n\xD8W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\t\xEDV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xA8W\x83\x82\x90_R` _ \x01\x80Ta\x0B\x83\x90a\x1F\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\xAF\x90a\x1F\xD3V[\x80\x15a\x0B\xFAW\x80`\x1F\x10a\x0B\xD1Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\xFAV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xDDW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0BfV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xA8W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\xF9W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C\xA6W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0C1V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xA8W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\xFCW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\xA9W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\r4V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xA8W\x83\x82\x90_R` _ \x01\x80Ta\x0ET\x90a\x1F\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0E\x80\x90a\x1F\xD3V[\x80\x15a\x0E\xCBW\x80`\x1F\x10a\x0E\xA2Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0E\xCBV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0E\xAEW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0E7V[`\x08T_\x90`\xFF\x16\x15a\x0E\xF6WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\x84W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xA8\x91\x90a!\xE9V[\x14\x15\x90P\x90V[sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xF2\x8D\xCE\xB3`@Q\x80``\x01`@R\x80`(\x81R` \x01aM5`(\x919`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x10\x14\x91\x90a\x1C\xE4V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10+W__\xFD[PZ\xF1\x15\x80\x15a\x10=W=__>=_\xFD[PP`\x1FT`@Q\x7F\x7F\xA67\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\x81Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92Pc\x7F\xA67\xFC\x91Pa\x04\x1C\x90`%\x90\x81\x90`!\x90`\x04\x01a!\x94V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x054W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x05\tWPPPPP\x90P\x90V[`'`&T`$T`@Qa\x11 \x90a\x1BSV[a\x11,\x93\x92\x91\x90a\"\x14V[`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x11EW=__>=_\xFD[P`\x1F\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\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\x90U`@\x80Q\x80\x82\x01\x82R`\x19\x81R\x7FInvalid retarget provided\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x12\x12\x91\x90`\x04\x01a\x1C\xE4V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12)W__\xFD[PZ\xF1\x15\x80\x15a\x12;W=__>=_\xFD[PP`\x1FT`@Q\x7F\x7F\xA67\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\x81Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92Pc\x7F\xA67\xFC\x91Pa\x04\x1C\x90`#\x90`'\x90`!\x90`\x04\x01a!\x94V[sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xF2\x8D\xCE\xB3`@Q\x80``\x01`@R\x80`=\x81R` \x01aM]`=\x919`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x13\x05\x91\x90a\x1C\xE4V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x13\x1CW__\xFD[PZ\xF1\x15\x80\x15a\x13.W=__>=_\xFD[PP`\x1FT`@Q\x7F\x7F\xA67\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\x81Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92Pc\x7F\xA67\xFC\x91Pa\x04\x1C\x90`#\x90\x81\x90`!\x90`\x04\x01a!\x94V[``a\x03$\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x17\xEAV[`@\x80Q\x80\x82\x01\x82R`\r\x81R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x14V\x91\x90`\x04\x01a\x1C\xE4V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x14mW__\xFD[PZ\xF1\x15\x80\x15a\x14\x7FW=__>=_\xFD[PPPP`\x1F`\x01\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\x7F\xA67\xFC`#a\x15\x93`@Q\x80`@\x01`@R\x80`\x0E\x81R` \x01\x7F.chain[15].hex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x80Ta\x15\t\x90a\x1F\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x155\x90a\x1F\xD3V[\x80\x15a\x15\x80W\x80`\x1F\x10a\x15WWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x15\x80V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15cW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x198\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[`!`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x04\x1C\x93\x92\x91\x90a\"8V[``a\x15\xBF\x84\x84a!BV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x15\xD7Wa\x15\xD7a\x1B`V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x16\nW\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x15\xF5W\x90P[P\x90P\x83[\x83\x81\x10\x15a\x16\x81Wa\x16S\x86a\x16$\x83a\x19\xCEV[\x85`@Q` \x01a\x167\x93\x92\x91\x90a\"\\V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x15\t\x90a\x1F\xD3V[\x82a\x16^\x87\x84a!BV[\x81Q\x81\x10a\x16nWa\x16na!UV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x16\x0FV[P\x94\x93PPPPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x16\xDE\x90\x86\x90\x86\x90`\x04\x01a\"\xEFV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x16\xF9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x17\x1D\x91\x90a!\xE9V[\x90P[\x92\x91PPV[``a\x172\x84\x84a!BV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17JWa\x17Ja\x1B`V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x17sW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x16\x81Wa\x17\xBC\x86a\x17\x8D\x83a\x19\xCEV[\x85`@Q` \x01a\x17\xA0\x93\x92\x91\x90a\"\\V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x06r\x90a\x1F\xD3V[\x82a\x17\xC7\x87\x84a!BV[\x81Q\x81\x10a\x17\xD7Wa\x17\xD7a!UV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x17xV[``a\x17\xF6\x84\x84a!BV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\x0EWa\x18\x0Ea\x1B`V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x187W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x16\x81Wa\x19\n\x86a\x18Q\x83a\x19\xCEV[\x85`@Q` \x01a\x18d\x93\x92\x91\x90a\"\\V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x18\x80\x90a\x1F\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x18\xAC\x90a\x1F\xD3V[\x80\x15a\x18\xF7W\x80`\x1F\x10a\x18\xCEWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x18\xF7V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x18\xDAW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x1A\xFF\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x19\x15\x87\x84a!BV[\x81Q\x81\x10a\x19%Wa\x19%a!UV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x18=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x17\x1D\x91\x90\x81\x01\x90a#\x13V[``\x81_\x03a\x1A\x10WPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x1A9W\x80a\x1A#\x81a#\x88V[\x91Pa\x1A2\x90P`\n\x83a#\xD3V[\x91Pa\x1A\x13V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1ASWa\x1ASa\x1B`V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x1A}W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x03$Wa\x1A\x92`\x01\x83a!BV[\x91Pa\x1A\x9F`\n\x86a#\xE6V[a\x1A\xAA\x90`0a!\xD6V[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x1A\xBFWa\x1A\xBFa!UV[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x1A\xF8`\n\x86a#\xD3V[\x94Pa\x1A\x81V[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x16\xDE\x90\x86\x90\x86\x90`\x04\x01a\"\xEFV[a);\x80a#\xFA\x839\x01\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x1B\x9DWa\x1B\x9Da\x1B`V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x1B\xBEWa\x1B\xBEa\x1B`V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x1B\xDEW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1B\xF4W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x1C\x04W__\xFD[\x805a\x1C\x17a\x1C\x12\x82a\x1B\xA5V[a\x1BtV[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x1C+W__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1C\xD8W`?\x19\x87\x86\x03\x01\x84Ra\x1C\xC3\x85\x83Qa\x1CSV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1C\xA7V[P\x92\x96\x95PPPPPPV[` \x81R_a\x17\x1D` \x83\x01\x84a\x1CSV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1DCW\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\x1D\x0FV[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x1D\x9CW`\x1F\x19\x85\x84\x03\x01\x88Ra\x1D\x86\x83\x83Qa\x1CSV[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x1DjV[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1C\xD8W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1E\x16`@\x87\x01\x82a\x1DNV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1D\xCEV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1DCW\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1EEV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x1E\xB5W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x1EuV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1C\xD8W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x1F\x0B`@\x88\x01\x82a\x1CSV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x1F&\x81\x83a\x1EcV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1E\xE5V[` \x81R_a\x17\x1D` \x83\x01\x84a\x1DNV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1C\xD8W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1F\xBD`@\x87\x01\x82a\x1EcV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1FuV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1F\xE7W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a \x05WcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[\x80T_\x90`\x01\x81\x81\x1C\x90\x82\x16\x80a #W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a AWcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[\x81\x86R` \x86\x01\x81\x80\x15a \\W`\x01\x81\x14a \x90Wa \xBCV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x85\x16\x82R\x83\x15\x15`\x05\x1B\x82\x01\x95Pa \xBCV[_\x87\x81R` \x90 _[\x85\x81\x10\x15a \xB6W\x81T\x84\x82\x01R`\x01\x90\x91\x01\x90` \x01a \x9AV[\x83\x01\x96PP[PPPPP\x92\x91PPV[``\x81R`\x01``\x82\x01R_`\x80\x82\x01R`\xA0` \x82\x01R_a \xED`\xA0\x83\x01\x85a \x0BV[\x82\x81\x03`@\x84\x01Ra \xFF\x81\x85a \x0BV[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a!\x18W__\xFD[\x81Q\x80\x15\x15\x81\x14a!'W__\xFD[\x93\x92PPPV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x17 Wa\x17 a!.V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x03$a!\x8E\x83\x86a!iV[\x84a!iV[``\x81R_a!\xA6``\x83\x01\x86a \x0BV[\x82\x81\x03` \x84\x01Ra!\xB8\x81\x86a \x0BV[\x90P\x82\x81\x03`@\x84\x01Ra!\xCC\x81\x85a \x0BV[\x96\x95PPPPPPV[\x80\x82\x01\x80\x82\x11\x15a\x17 Wa\x17 a!.V[_` \x82\x84\x03\x12\x15a!\xF9W__\xFD[PQ\x91\x90PV[cNH{q`\xE0\x1B_R`\x01`\x04R`$_\xFD[``\x81R_a\"&``\x83\x01\x86a \x0BV[` \x83\x01\x94\x90\x94RP`@\x01R\x91\x90PV[``\x81R_a\"J``\x83\x01\x86a \x0BV[\x82\x81\x03` \x84\x01Ra!\xB8\x81\x86a\x1CSV[\x7F.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R_a\"\x8D`\x01\x83\x01\x86a!iV[\x7F[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\"\xBD`\x01\x82\x01\x86a!iV[\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\x81Ra!\xCC`\x02\x82\x01\x85a!iV[`@\x81R_a#\x01`@\x83\x01\x85a\x1CSV[\x82\x81\x03` \x84\x01Ra \xFF\x81\x85a\x1CSV[_` \x82\x84\x03\x12\x15a##W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a#9W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a#IW__\xFD[\x80Qa#Wa\x1C\x12\x82a\x1B\xA5V[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a#kW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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#\xB8Wa#\xB8a!.V[P`\x01\x01\x90V[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a#\xE1Wa#\xE1a#\xBFV[P\x04\x90V[_\x82a#\xF4Wa#\xF4a#\xBFV[P\x06\x90V\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa);8\x03\x80a);\x839\x81\x01`@\x81\x90Ra\0.\x91a\x03+V[\x82\x82\x82\x82\x82\x82a\0?\x83Q`P\x14\x90V[a\0\x84W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x11`$\x82\x01RpBad genesis block`x\x1B`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\0\x8E\x84a\x01fV[\x90Pb\xFF\xFF\xFF\x82\x16\x15a\x01\tW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FPeriod start hash does not have `D\x82\x01R\x7Fwork. Hint: wrong byte order?\0\0\0`d\x82\x01R`\x84\x01a\0{V[_\x81\x81U`\x01\x82\x90U`\x02\x82\x90U\x81\x81R`\x04` R`@\x90 \x83\x90Ua\x012a\x07\xE0\x84a\x03\xFEV[a\x01<\x90\x84a\x04%V[_\x83\x81R`\x04` R`@\x90 Ua\x01S\x84a\x02&V[`\x05UPa\x05\xBD\x98PPPPPPPPPV[_`\x02\x80\x83`@Qa\x01x\x91\x90a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\x93W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x04NV[`@Q` \x01a\x01\xC8\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x01\xE2\x91a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\xFDW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02 \x91\x90a\x04NV[\x92\x91PPV[_a\x02 a\x023\x83a\x028V[a\x02CV[_a\x02 \x82\x82a\x02SV[_a\x02 a\xFF\xFF`\xD0\x1B\x83a\x02\xF7V[_\x80a\x02ja\x02c\x84`Ha\x04eV[\x85\x90a\x03\tV[`\xE8\x1C\x90P_\x84a\x02|\x85`Ka\x04eV[\x81Q\x81\x10a\x02\x8CWa\x02\x8Ca\x04xV[\x01` \x01Q`\xF8\x1C\x90P_a\x02\xBE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x02\xD1`\x03\x84a\x04\x8CV[`\xFF\x16\x90Pa\x02\xE2\x81a\x01\0a\x05\x88V[a\x02\xEC\x90\x83a\x05\x93V[\x97\x96PPPPPPPV[_a\x03\x02\x82\x84a\x05\xAAV[\x93\x92PPPV[_a\x03\x02\x83\x83\x01` \x01Q\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x03=W__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03RW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03bW__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03{Wa\x03{a\x03\x17V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x03\xA9Wa\x03\xA9a\x03\x17V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x03\xC0W__\xFD[\x81` \x84\x01` \x83\x01^_` \x92\x82\x01\x83\x01R\x90\x86\x01Q`@\x90\x96\x01Q\x90\x97\x95\x96P\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x04\x0CWa\x04\x0Ca\x03\xEAV[P\x06\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x04^W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02 Wa\x02 a\x04\x11V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[`\x01\x81[`\x01\x84\x11\x15a\x04\xE0W\x80\x85\x04\x81\x11\x15a\x04\xC4Wa\x04\xC4a\x04\x11V[`\x01\x84\x16\x15a\x04\xD2W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x04\xA9V[\x93P\x93\x91PPV[_\x82a\x04\xF6WP`\x01a\x02 V[\x81a\x05\x02WP_a\x02 V[\x81`\x01\x81\x14a\x05\x18W`\x02\x81\x14a\x05\"Wa\x05>V[`\x01\x91PPa\x02 V[`\xFF\x84\x11\x15a\x053Wa\x053a\x04\x11V[PP`\x01\x82\x1Ba\x02 V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x05aWP\x81\x81\na\x02 V[a\x05m_\x19\x84\x84a\x04\xA5V[\x80_\x19\x04\x82\x11\x15a\x05\x80Wa\x05\x80a\x04\x11V[\x02\x93\x92PPPV[_a\x03\x02\x83\x83a\x04\xE8V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x02 Wa\x02 a\x04\x11V[_\x82a\x05\xB8Wa\x05\xB8a\x03\xEAV[P\x04\x90V[a#q\x80a\x05\xCA_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\xADW\x80c\xB9\x85b\x1A\x11a\0}W\x80c\xE3\xD8\xD8\xD8\x11a\0cW\x80c\xE3\xD8\xD8\xD8\x14a\x02\"W\x80c\xE4q\xE7,\x14a\x02)W\x80c\xF5\x8D\xB0o\x14a\x02=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x13\x91\x90a!WV[`@Q` \x01a\x0C%\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\x90\x82\x90Ra\x0C]\x91a!AV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0CxW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x07\x91\x90a!WV[_\x83\x85\x14\x80\x15a\x0C\xAAWP\x82\x85\x14[\x15a\x0C\xB7WP`\x01a\x04\xF1V[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x0C\xFFW\x89\x83\x14a\x0C\xDEW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x0C\xF7W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x0C\xBDV[P\x82\x84\x03a\r\x13W_\x94PPPPPa\x04\xF1V[\x80\x82\x14a\r&W_\x94PPPPPa\x04\xF1V[P`\x01\x98\x97PPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\rYW_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\r9V[P\x80a\x05\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x80\x82\x81[a\r\xB8`\x04`\x01a!\x9BV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0E\x0CW_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\r\xF1W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0E\x04V[a\r\xFB\x81\x84a!\xB7V[\x95\x94PPPPPV[`\x01\x01a\r\xACV[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_`P\x82Qa\x0B~\x91\x90a!.V[__a\x0Eo\x85a\x0B\xC3V[\x90P_a\x0E{\x82a\r\xA7V[\x90P_a\x0E\x87\x86a\x19\xE6V[\x90P\x84\x80a\x0E\x9CWP\x80a\x0E\x9A\x88a\x19\xE6V[\x14[a\x0F\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x03.V[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x12\x0EWa\x0F(`P\x82a!\xCAV[a\x0F3\x90`\x01a!\xB7V[a\x0F=\x90\x87a!\xB7V[\x93Pa\x0FK\x8A\x82`Pa\x19\xF1V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x11!W\x84a\x10\xA1\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x10\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x11\n`\x04\x85a!.V[_\x03a\x11!W_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x11,\x8B\x83a\x1A\x16V[\x14a\x11yW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[\x86a\x11\x84\x8B\x83a\x1A\xAFV[\x14a\x11\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x03.V[\x82\x96P`P\x81a\x12\x07\x91\x90a!\xB7V[\x90Pa\x0F\x15V[P\x81a\x12\x19\x8Ba\x0B\xC3V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x12\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x12\xD4\x84a\x0B\xC3V[\x90P_a\x12\xE0\x86a\x0B\xC3V[\x90P`\x01T\x81\x14a\x133W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x03.V[_\x82\x81R`\x03` R`@\x90 Ta\x13\x8DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x13\x9B\x87`\x01T\x84\x87a\x0C\x9BV[a\x14\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x03.V[\x81a\x14\x19\x88\x88\x88a\x17\x80V[\x14a\x14\x8CW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[`\x01\x82\x90U`\x02\x87\x90U_a\x14\xA0\x86a\x1A\xC7V[\x90P`\x05T\x81\x14a\x14\xB1W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x15\x01a\x14\xFC\x86a\x0B\xC3V[a\r\xA7V[\x90P_a\x15\x10a\x14\xFC\x86a\x0B\xC3V[\x90Pa\x15\x1Ea\x07\xE0\x82a!.V[a\x07\xDF\x14a\x15\x94W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x03.V[a\x15\xA0\x82a\x07\xDFa!\xB7V[\x81\x14a\x16\x14W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x03.V[a\x16\x1D\x85a\x1A\xC7V[a\x16&\x87a\x1A\xC7V[\x14a\x16\x99W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x03.V[_a\x16\xA3\x85a\x19\xE6V[\x90P_a\x16\xD5a\x16\xB2\x89a\x19\xE6V[a\x16\xBB\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x16\xCA\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x1B\x0CV[\x90P\x81\x81\x83\x16\x14a\x17(W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_a\x172\x89a\x1A\xC7V[\x90P\x80`\x06T\x14\x15\x80\x15a\x17\\WPa\x07\xE0a\x17O`\x01Ta\r\xA7V[a\x17Y\x91\x90a!\xDDV[\x84\x11[\x15a\x17gW`\x06\x81\x90U[a\x17s\x88\x88`\x01a\x0EdV[\x99\x98PPPPPPPPPV[__a\x17\x8B\x85a\r\xA7V[\x90P_a\x17\x9Aa\x14\xFC\x86a\x0B\xC3V[\x90P_a\x17\xA9a\x14\xFC\x86a\x0B\xC3V[\x90P\x82\x82\x10\x15\x80\x15a\x17\xBBWP\x82\x81\x10\x15[a\x18-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x18:a\x07\xE0\x85a!.V[a\x18F\x85a\x07\xE0a!\xB7V[a\x18P\x91\x90a!\xDDV[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x18bWP\x80[\x15a\x18}Wa\x18p\x89a\x0B\xC3V[\x96PPPPPPPa\n\xA3V[\x81\x80\x15a\x18\x88WP\x80\x15[\x15a\x18\x96Wa\x18p\x88a\x0B\xC3V[\x81\x80\x15a\x18\xA0WP\x80[\x15a\x18\xC4W\x83\x85\x10\x15a\x18\xBBWa\x18\xB6\x88a\x0B\xC3V[a\x18pV[a\x18p\x89a\x0B\xC3V[a\x18\xCD\x88a\x1A\xC7V[a\x18\xD9a\x07\xE0\x86a!.V[a\x18\xE3\x91\x90a!\xF0V[a\x18\xEC\x8Aa\x1A\xC7V[a\x18\xF8a\x07\xE0\x88a!.V[a\x19\x02\x91\x90a!\xF0V[\x10\x15a\x18\xBBWa\x18p\x88a\x0B\xC3V[`\x07T_\x90`\xFF\x16\x15a\x19/WP`\x07Ta\x01\0\x90\x04`\xFF\x16a\n\xA3V[a\x19:\x84\x84\x84a\x1B\x94V[\x90Pa\n\xA3V[_` \x84Qa\x19P\x91\x90a!.V[\x15a\x19\\WP_a\x04\xF1V[\x83Q_\x03a\x19kWP_a\x04\xF1V[\x81\x85_[\x86Q\x81\x10\x15a\x19\xD9Wa\x19\x83`\x02\x84a!.V[`\x01\x03a\x19\xA7Wa\x19\xA0a\x19\x9A\x88\x83\x01` \x01Q\x90V[\x83a\x1B\xD5V[\x91Pa\x19\xC0V[a\x19\xBD\x82a\x19\xB8\x89\x84\x01` \x01Q\x90V[a\x1B\xD5V[\x91P[`\x01\x92\x90\x92\x1C\x91a\x19\xD2` \x82a!\xB7V[\x90Pa\x19oV[P\x90\x93\x14\x95\x94PPPPPV[_a\x05\x07\x82_a\x1A\x16V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x1A-a\x1A&\x84`Ha!\xB7V[\x85\x90a\x1B\xE0V[`\xE8\x1C\x90P_\x84a\x1A?\x85`Ka!\xB7V[\x81Q\x81\x10a\x1AOWa\x1AOa\"\x07V[\x01` \x01Q`\xF8\x1C\x90P_a\x1A\x81\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1A\x94`\x03\x84a\"4V[`\xFF\x16\x90Pa\x1A\xA5\x81a\x01\0a#0V[a\x08-\x90\x83a!\xF0V[_a\x05\x04a\x1A\xBE\x83`\x04a!\xB7V[\x84\x01` \x01Q\x90V[_a\x05\x07a\x1A\xD4\x83a\x19\xE6V[a\x1B\xEEV[_a\x05\x07a\x1A\xE6\x83a\x1C\x15V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1B\x18\x83\x85a\x1C!V[\x90Pa\x1B(b\x12u\0`\x04a\x1C|V[\x81\x10\x15a\x1B@Wa\x1B=b\x12u\0`\x04a\x1C|V[\x90P[a\x1BNb\x12u\0`\x04a\x1C\x87V[\x81\x11\x15a\x1BfWa\x1Bcb\x12u\0`\x04a\x1C\x87V[\x90P[_a\x1B~\x82a\x1Bx\x88b\x01\0\0a\x1C|V[\x90a\x1C\x87V[\x90Pa\n\x8Ab\x01\0\0a\x1Bx\x83b\x12u\0a\x1C|V[_\x82\x81[\x83\x81\x10\x15a\x1B\xCAW\x85\x82\x03a\x1B\xB2W`\x01\x92PPPa\n\xA3V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x1B\x98V[P_\x95\x94PPPPPV[_a\x05\x04\x83\x83a\x1C\xFAV[_a\x05\x04\x83\x83\x01` \x01Q\x90V[_a\x05\x07{\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\x83a\x1C|V[_a\x05\x07\x82`Da\x1B\xE0V[_\x82\x82\x11\x15a\x1CrW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x05\x04\x82\x84a!\xDDV[_a\x05\x04\x82\x84a!\xCAV[_\x82_\x03a\x1C\x96WP_a\x05\x07V[a\x1C\xA0\x82\x84a!\xF0V[\x90P\x81a\x1C\xAD\x84\x83a!\xCAV[\x14a\x05\x07W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x03.V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1D1W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DHW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1D_W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1DvW__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1D\x91W__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xA7W__\xFD[a\x1D\xB3\x8A\x82\x8B\x01a\x1D!V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xD2W__\xFD[a\x1D\xDE\x8A\x82\x8B\x01a\x1D!V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1D\xFE`\x80\x89\x01a\x1DfV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[____`\x80\x85\x87\x03\x12\x15a\x1E\x1FW__\xFD[PP\x825\x94` \x84\x015\x94P`@\x84\x015\x93``\x015\x92P\x90PV[__`@\x83\x85\x03\x12\x15a\x1ELW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1EkW__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1E\x85W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x9BW__\xFD[a\x1E\xA7\x87\x82\x88\x01a\x1D!V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\xC6W__\xFD[a\x1E\xD2\x87\x82\x88\x01a\x1D!V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1E\xF3W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x10W__\xFD[a\x1F\x1C\x89\x82\x8A\x01a\x1D!V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F;W__\xFD[a\x1FG\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1FtW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x8AW__\xFD[a\x1F\x96\x89\x82\x8A\x01a\x1D!V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xB5W__\xFD[a\x1F\xC1\x89\x82\x8A\x01a\x1D!V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xE0W__\xFD[a\x1F\xEC\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_____``\x86\x88\x03\x12\x15a \x12W__\xFD[\x855\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a /W__\xFD[a ;\x88\x82\x89\x01a\x1D!V[\x90\x95P\x93PP`@\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a ZW__\xFD[a f\x88\x82\x89\x01a\x1D!V[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[___``\x84\x86\x03\x12\x15a \x89W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a \xB1W__\xFD[\x825\x91Pa \xC1` \x84\x01a\x1DfV[\x90P\x92P\x92\x90PV[\x805\x80\x15\x15\x81\x14a\x1DvW__\xFD[__`@\x83\x85\x03\x12\x15a \xEAW__\xFD[a \xF3\x83a \xCAV[\x91Pa \xC1` \x84\x01a \xCAV[\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! = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolConstructor for constructorCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getBlockHeights(string,uint256,uint256)` and selector `0xfad06b8f`. -```solidity -function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getBlockHeightsCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getBlockHeights(string,uint256,uint256)`](getBlockHeightsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getBlockHeightsReturn { - #[allow(missing_docs)] - pub elements: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getBlockHeightsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - #[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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getBlockHeightsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getBlockHeightsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getBlockHeights(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [250u8, 208u8, 107u8, 143u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getDigestLes(string,uint256,uint256)` and selector `0x44badbb6`. -```solidity -function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getDigestLesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getDigestLes(string,uint256,uint256)`](getDigestLesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getDigestLesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getDigestLesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getDigestLesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getDigestLesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array< - alloy::sol_types::sol_data::FixedBytes<32>, - >, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getDigestLes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [68u8, 186u8, 219u8, 182u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaderHexes(string,uint256,uint256)` and selector `0x0813852a`. -```solidity -function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaderHexes(string,uint256,uint256)`](getHeaderHexesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeaderHexesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getHeaderHexesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getHeaderHexesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Bytes, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaderHexes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [8u8, 19u8, 133u8, 42u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaders(string,uint256,uint256)` and selector `0x1c0da81f`. -```solidity -function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaders(string,uint256,uint256)`](getHeadersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersReturn { - #[allow(missing_docs)] - pub headers: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersReturn) -> Self { - (value.headers,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { headers: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getHeadersCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Bytes; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaders(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [28u8, 13u8, 168u8, 31u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testAppendsNewLinksToTheChain()` and selector `0x260a40d8`. -```solidity -function testAppendsNewLinksToTheChain() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testAppendsNewLinksToTheChainCall; - ///Container type for the return parameters of the [`testAppendsNewLinksToTheChain()`](testAppendsNewLinksToTheChainCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testAppendsNewLinksToTheChainReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testAppendsNewLinksToTheChainCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testAppendsNewLinksToTheChainCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testAppendsNewLinksToTheChainReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testAppendsNewLinksToTheChainReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testAppendsNewLinksToTheChainReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testAppendsNewLinksToTheChainCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testAppendsNewLinksToTheChainReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testAppendsNewLinksToTheChain()"; - const SELECTOR: [u8; 4] = [38u8, 10u8, 64u8, 216u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testAppendsNewLinksToTheChainReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testOldPeriodEndHeaderUnknown()` and selector `0xfdd98e03`. -```solidity -function testOldPeriodEndHeaderUnknown() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testOldPeriodEndHeaderUnknownCall; - ///Container type for the return parameters of the [`testOldPeriodEndHeaderUnknown()`](testOldPeriodEndHeaderUnknownCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testOldPeriodEndHeaderUnknownReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testOldPeriodEndHeaderUnknownCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testOldPeriodEndHeaderUnknownCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testOldPeriodEndHeaderUnknownReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testOldPeriodEndHeaderUnknownReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testOldPeriodEndHeaderUnknownReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testOldPeriodEndHeaderUnknownCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testOldPeriodEndHeaderUnknownReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testOldPeriodEndHeaderUnknown()"; - const SELECTOR: [u8; 4] = [253u8, 217u8, 142u8, 3u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testOldPeriodEndHeaderUnknownReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testOldPeriodEndMismatch()` and selector `0xee761812`. -```solidity -function testOldPeriodEndMismatch() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testOldPeriodEndMismatchCall; - ///Container type for the return parameters of the [`testOldPeriodEndMismatch()`](testOldPeriodEndMismatchCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testOldPeriodEndMismatchReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testOldPeriodEndMismatchCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testOldPeriodEndMismatchCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testOldPeriodEndMismatchReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testOldPeriodEndMismatchReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testOldPeriodEndMismatchReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testOldPeriodEndMismatchCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testOldPeriodEndMismatchReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testOldPeriodEndMismatch()"; - const SELECTOR: [u8; 4] = [238u8, 118u8, 24u8, 18u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testOldPeriodEndMismatchReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testOldPeriodStartHeaderUnknown()` and selector `0x0a620f07`. -```solidity -function testOldPeriodStartHeaderUnknown() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testOldPeriodStartHeaderUnknownCall; - ///Container type for the return parameters of the [`testOldPeriodStartHeaderUnknown()`](testOldPeriodStartHeaderUnknownCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testOldPeriodStartHeaderUnknownReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testOldPeriodStartHeaderUnknownCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testOldPeriodStartHeaderUnknownCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testOldPeriodStartHeaderUnknownReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testOldPeriodStartHeaderUnknownReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testOldPeriodStartHeaderUnknownReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testOldPeriodStartHeaderUnknownCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testOldPeriodStartHeaderUnknownReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testOldPeriodStartHeaderUnknown()"; - const SELECTOR: [u8; 4] = [10u8, 98u8, 15u8, 7u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testOldPeriodStartHeaderUnknownReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testOldPeriodStartToEndNot2015Blocks()` and selector `0xc06322c3`. -```solidity -function testOldPeriodStartToEndNot2015Blocks() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testOldPeriodStartToEndNot2015BlocksCall; - ///Container type for the return parameters of the [`testOldPeriodStartToEndNot2015Blocks()`](testOldPeriodStartToEndNot2015BlocksCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testOldPeriodStartToEndNot2015BlocksReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testOldPeriodStartToEndNot2015BlocksCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testOldPeriodStartToEndNot2015BlocksCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testOldPeriodStartToEndNot2015BlocksReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testOldPeriodStartToEndNot2015BlocksReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testOldPeriodStartToEndNot2015BlocksReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testOldPeriodStartToEndNot2015BlocksCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testOldPeriodStartToEndNot2015BlocksReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testOldPeriodStartToEndNot2015Blocks()"; - const SELECTOR: [u8; 4] = [192u8, 99u8, 34u8, 195u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testOldPeriodStartToEndNot2015BlocksReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testRetargetPerformedIncorrectly()` and selector `0xe8c705c8`. -```solidity -function testRetargetPerformedIncorrectly() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testRetargetPerformedIncorrectlyCall; - ///Container type for the return parameters of the [`testRetargetPerformedIncorrectly()`](testRetargetPerformedIncorrectlyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testRetargetPerformedIncorrectlyReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testRetargetPerformedIncorrectlyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testRetargetPerformedIncorrectlyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testRetargetPerformedIncorrectlyReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testRetargetPerformedIncorrectlyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testRetargetPerformedIncorrectlyReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testRetargetPerformedIncorrectlyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testRetargetPerformedIncorrectlyReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testRetargetPerformedIncorrectly()"; - const SELECTOR: [u8; 4] = [232u8, 199u8, 5u8, 200u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testRetargetPerformedIncorrectlyReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`FullRelayAddHeaderWithRetargetTest`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum FullRelayAddHeaderWithRetargetTestCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - getBlockHeights(getBlockHeightsCall), - #[allow(missing_docs)] - getDigestLes(getDigestLesCall), - #[allow(missing_docs)] - getHeaderHexes(getHeaderHexesCall), - #[allow(missing_docs)] - getHeaders(getHeadersCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - testAppendsNewLinksToTheChain(testAppendsNewLinksToTheChainCall), - #[allow(missing_docs)] - testOldPeriodEndHeaderUnknown(testOldPeriodEndHeaderUnknownCall), - #[allow(missing_docs)] - testOldPeriodEndMismatch(testOldPeriodEndMismatchCall), - #[allow(missing_docs)] - testOldPeriodStartHeaderUnknown(testOldPeriodStartHeaderUnknownCall), - #[allow(missing_docs)] - testOldPeriodStartToEndNot2015Blocks(testOldPeriodStartToEndNot2015BlocksCall), - #[allow(missing_docs)] - testRetargetPerformedIncorrectly(testRetargetPerformedIncorrectlyCall), - } - #[automatically_derived] - impl FullRelayAddHeaderWithRetargetTestCalls { - /// 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, 19u8, 133u8, 42u8], - [10u8, 98u8, 15u8, 7u8], - [28u8, 13u8, 168u8, 31u8], - [30u8, 215u8, 131u8, 28u8], - [38u8, 10u8, 64u8, 216u8], - [42u8, 222u8, 56u8, 128u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [68u8, 186u8, 219u8, 182u8], - [102u8, 217u8, 169u8, 160u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [192u8, 99u8, 34u8, 195u8], - [226u8, 12u8, 159u8, 113u8], - [232u8, 199u8, 5u8, 200u8], - [238u8, 118u8, 24u8, 18u8], - [250u8, 118u8, 38u8, 212u8], - [250u8, 208u8, 107u8, 143u8], - [253u8, 217u8, 142u8, 3u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for FullRelayAddHeaderWithRetargetTestCalls { - const NAME: &'static str = "FullRelayAddHeaderWithRetargetTestCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 22usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::getBlockHeights(_) => { - ::SELECTOR - } - Self::getDigestLes(_) => { - ::SELECTOR - } - Self::getHeaderHexes(_) => { - ::SELECTOR - } - Self::getHeaders(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::testAppendsNewLinksToTheChain(_) => { - ::SELECTOR - } - Self::testOldPeriodEndHeaderUnknown(_) => { - ::SELECTOR - } - Self::testOldPeriodEndMismatch(_) => { - ::SELECTOR - } - Self::testOldPeriodStartHeaderUnknown(_) => { - ::SELECTOR - } - Self::testOldPeriodStartToEndNot2015Blocks(_) => { - ::SELECTOR - } - Self::testRetargetPerformedIncorrectly(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderWithRetargetTestCalls::getHeaderHexes) - } - getHeaderHexes - }, - { - fn testOldPeriodStartHeaderUnknown( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::testOldPeriodStartHeaderUnknown, - ) - } - testOldPeriodStartHeaderUnknown - }, - { - fn getHeaders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderWithRetargetTestCalls::getHeaders) - } - getHeaders - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderWithRetargetTestCalls::excludeSenders) - } - excludeSenders - }, - { - fn testAppendsNewLinksToTheChain( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::testAppendsNewLinksToTheChain, - ) - } - testAppendsNewLinksToTheChain - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::targetInterfaces, - ) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderWithRetargetTestCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::targetContracts, - ) - } - targetContracts - }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map(FullRelayAddHeaderWithRetargetTestCalls::getDigestLes) - } - getDigestLes - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::targetArtifacts, - ) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::targetSelectors, - ) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::excludeSelectors, - ) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::excludeArtifacts, - ) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw(data) - .map(FullRelayAddHeaderWithRetargetTestCalls::failed) - } - failed - }, - { - fn testOldPeriodStartToEndNot2015Blocks( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::testOldPeriodStartToEndNot2015Blocks, - ) - } - testOldPeriodStartToEndNot2015Blocks - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::excludeContracts, - ) - } - excludeContracts - }, - { - fn testRetargetPerformedIncorrectly( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::testRetargetPerformedIncorrectly, - ) - } - testRetargetPerformedIncorrectly - }, - { - fn testOldPeriodEndMismatch( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::testOldPeriodEndMismatch, - ) - } - testOldPeriodEndMismatch - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw(data) - .map(FullRelayAddHeaderWithRetargetTestCalls::IS_TEST) - } - IS_TEST - }, - { - fn getBlockHeights( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::getBlockHeights, - ) - } - getBlockHeights - }, - { - fn testOldPeriodEndHeaderUnknown( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::testOldPeriodEndHeaderUnknown, - ) - } - testOldPeriodEndHeaderUnknown - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderWithRetargetTestCalls::getHeaderHexes) - } - getHeaderHexes - }, - { - fn testOldPeriodStartHeaderUnknown( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::testOldPeriodStartHeaderUnknown, - ) - } - testOldPeriodStartHeaderUnknown - }, - { - fn getHeaders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderWithRetargetTestCalls::getHeaders) - } - getHeaders - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderWithRetargetTestCalls::excludeSenders) - } - excludeSenders - }, - { - fn testAppendsNewLinksToTheChain( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::testAppendsNewLinksToTheChain, - ) - } - testAppendsNewLinksToTheChain - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::targetInterfaces, - ) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderWithRetargetTestCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::targetContracts, - ) - } - targetContracts - }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderWithRetargetTestCalls::getDigestLes) - } - getDigestLes - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::targetArtifacts, - ) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::targetSelectors, - ) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::excludeSelectors, - ) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::excludeArtifacts, - ) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderWithRetargetTestCalls::failed) - } - failed - }, - { - fn testOldPeriodStartToEndNot2015Blocks( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::testOldPeriodStartToEndNot2015Blocks, - ) - } - testOldPeriodStartToEndNot2015Blocks - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::excludeContracts, - ) - } - excludeContracts - }, - { - fn testRetargetPerformedIncorrectly( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::testRetargetPerformedIncorrectly, - ) - } - testRetargetPerformedIncorrectly - }, - { - fn testOldPeriodEndMismatch( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::testOldPeriodEndMismatch, - ) - } - testOldPeriodEndMismatch - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayAddHeaderWithRetargetTestCalls::IS_TEST) - } - IS_TEST - }, - { - fn getBlockHeights( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::getBlockHeights, - ) - } - getBlockHeights - }, - { - fn testOldPeriodEndHeaderUnknown( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayAddHeaderWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayAddHeaderWithRetargetTestCalls::testOldPeriodEndHeaderUnknown, - ) - } - testOldPeriodEndHeaderUnknown - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::getBlockHeights(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getDigestLes(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getHeaders(inner) => { - ::abi_encoded_size(inner) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testAppendsNewLinksToTheChain(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testOldPeriodEndHeaderUnknown(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testOldPeriodEndMismatch(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testOldPeriodStartHeaderUnknown(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testOldPeriodStartToEndNot2015Blocks(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testRetargetPerformedIncorrectly(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::getBlockHeights(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getDigestLes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testAppendsNewLinksToTheChain(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testOldPeriodEndHeaderUnknown(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testOldPeriodEndMismatch(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testOldPeriodStartHeaderUnknown(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testOldPeriodStartToEndNot2015Blocks(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testRetargetPerformedIncorrectly(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`FullRelayAddHeaderWithRetargetTest`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum FullRelayAddHeaderWithRetargetTestEvents { - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl FullRelayAddHeaderWithRetargetTestEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface - for FullRelayAddHeaderWithRetargetTestEvents { - const NAME: &'static str = "FullRelayAddHeaderWithRetargetTestEvents"; - const COUNT: usize = 22usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 FullRelayAddHeaderWithRetargetTestEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`FullRelayAddHeaderWithRetargetTest`](self) contract instance. - -See the [wrapper's documentation](`FullRelayAddHeaderWithRetargetTestInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> FullRelayAddHeaderWithRetargetTestInstance { - FullRelayAddHeaderWithRetargetTestInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - FullRelayAddHeaderWithRetargetTestInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - FullRelayAddHeaderWithRetargetTestInstance::::deploy_builder(provider) - } - /**A [`FullRelayAddHeaderWithRetargetTest`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`FullRelayAddHeaderWithRetargetTest`](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 FullRelayAddHeaderWithRetargetTestInstance< - P, - N = alloy_contract::private::Ethereum, - > { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for FullRelayAddHeaderWithRetargetTestInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("FullRelayAddHeaderWithRetargetTestInstance") - .field(&self.address) - .finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayAddHeaderWithRetargetTestInstance { - /**Creates a new wrapper around an on-chain [`FullRelayAddHeaderWithRetargetTest`](self) contract instance. - -See the [wrapper's documentation](`FullRelayAddHeaderWithRetargetTestInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 FullRelayAddHeaderWithRetargetTestInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider( - self, - ) -> FullRelayAddHeaderWithRetargetTestInstance { - FullRelayAddHeaderWithRetargetTestInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayAddHeaderWithRetargetTestInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`getBlockHeights`] function. - pub fn getBlockHeights( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getBlockHeightsCall, N> { - self.call_builder( - &getBlockHeightsCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getDigestLes`] function. - pub fn getDigestLes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getDigestLesCall, N> { - self.call_builder( - &getDigestLesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaderHexes`] function. - pub fn getHeaderHexes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeaderHexesCall, N> { - self.call_builder( - &getHeaderHexesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaders`] function. - pub fn getHeaders( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeadersCall, N> { - self.call_builder( - &getHeadersCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`testAppendsNewLinksToTheChain`] function. - pub fn testAppendsNewLinksToTheChain( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testAppendsNewLinksToTheChainCall, N> { - self.call_builder(&testAppendsNewLinksToTheChainCall) - } - ///Creates a new call builder for the [`testOldPeriodEndHeaderUnknown`] function. - pub fn testOldPeriodEndHeaderUnknown( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testOldPeriodEndHeaderUnknownCall, N> { - self.call_builder(&testOldPeriodEndHeaderUnknownCall) - } - ///Creates a new call builder for the [`testOldPeriodEndMismatch`] function. - pub fn testOldPeriodEndMismatch( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testOldPeriodEndMismatchCall, N> { - self.call_builder(&testOldPeriodEndMismatchCall) - } - ///Creates a new call builder for the [`testOldPeriodStartHeaderUnknown`] function. - pub fn testOldPeriodStartHeaderUnknown( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testOldPeriodStartHeaderUnknownCall, N> { - self.call_builder(&testOldPeriodStartHeaderUnknownCall) - } - ///Creates a new call builder for the [`testOldPeriodStartToEndNot2015Blocks`] function. - pub fn testOldPeriodStartToEndNot2015Blocks( - &self, - ) -> alloy_contract::SolCallBuilder< - &P, - testOldPeriodStartToEndNot2015BlocksCall, - N, - > { - self.call_builder(&testOldPeriodStartToEndNot2015BlocksCall) - } - ///Creates a new call builder for the [`testRetargetPerformedIncorrectly`] function. - pub fn testRetargetPerformedIncorrectly( - &self, - ) -> alloy_contract::SolCallBuilder< - &P, - testRetargetPerformedIncorrectlyCall, - N, - > { - self.call_builder(&testRetargetPerformedIncorrectlyCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayAddHeaderWithRetargetTestInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/fullrelayconstructiontest.rs b/crates/bindings/src/fullrelayconstructiontest.rs deleted file mode 100644 index 215935f1b..000000000 --- a/crates/bindings/src/fullrelayconstructiontest.rs +++ /dev/null @@ -1,8899 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface FullRelayConstructionTest { - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - constructor(); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); - function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); - function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); - function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function testBadGenesisBlock() external; - function testPeriodStartWrongByteOrder() external; - function testStoresGenesisBlockInfo() external view; -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getBlockHeights", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getDigestLes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes32[]", - "internalType": "bytes32[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaderHexes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes[]", - "internalType": "bytes[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaders", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "headers", - "type": "bytes", - "internalType": "bytes" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testBadGenesisBlock", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testPeriodStartWrongByteOrder", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testStoresGenesisBlockInfo", - "inputs": [], - "outputs": [], - "stateMutability": "view" - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 FullRelayConstructionTest { - use super::*; - use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15a\0,W__\xFD[P`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k42\xB0\xB22\xB99\x9759\xB7\xB7`\xA1\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k\x05\xCC\xEC\xAD\xCC\xAEm.e\xCD\x0C\xAF`\xA3\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x0F\x81R` \x01n\x0B\x99\xD9[\x99\\\xDA\\\xCB\x9A\x19ZY\xDA\x1D`\x8A\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x18\x81R` \x01\x7F.orphan_562630.digest_le\0\0\0\0\0\0\0\0\x81RP__Q` a}\xD2_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x16c\xD90\xA0\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\x1EW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01E\x91\x90\x81\x01\x90a\x07#V[\x90P_\x81\x86`@Q` \x01a\x01[\x92\x91\x90a\x07\x86V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Rc`\xF9\xBB\x11`\xE0\x1B\x82R\x91P_Q` a}\xD2_9_Q\x90_R\x90c`\xF9\xBB\x11\x90a\x01\x9B\x90\x84\x90`\x04\x01a\x07\xF8V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xB5W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01\xDC\x91\x90\x81\x01\x90a\x07#V[` \x90a\x01\xE9\x90\x82a\x08\x8EV[Pa\x02\x80\x85` \x80Ta\x01\xFB\x90a\x08\nV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02'\x90a\x08\nV[\x80\x15a\x02rW\x80`\x1F\x10a\x02IWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02rV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02UW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x05i\x91PPV[a\x03\x16\x85` \x80Ta\x02\x91\x90a\x08\nV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\xBD\x90a\x08\nV[\x80\x15a\x03\x08W\x80`\x1F\x10a\x02\xDFWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\x08V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02\xEBW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x05\xE6\x91PPV[a\x03\xAC\x85` \x80Ta\x03'\x90a\x08\nV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03S\x90a\x08\nV[\x80\x15a\x03\x9EW\x80`\x1F\x10a\x03uWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\x9EV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\x81W\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x06Y\x91PPV[`@Qa\x03\xB8\x90a\x06\x8DV[a\x03\xC4\x93\x92\x91\x90a\tHV[`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03\xDDW=__>=_\xFD[P`\x1F`\x01a\x01\0\n\x81T\x81`\x01`\x01`\xA0\x1B\x03\x02\x19\x16\x90\x83`\x01`\x01`\xA0\x1B\x03\x16\x02\x17\x90UPPPPPPPa\x04E`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01q.genesis.digest_le`p\x1B\x81RP` \x80Ta\x03'\x90a\x08\nV[`!\x81\x90UPa\x04\x91`@Q\x80`@\x01`@R\x80`\x15\x81R` \x01\x7F.orphan_562630.digest\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x80Ta\x03'\x90a\x08\nV[`\"\x81\x90UPa\x04\xDD`@Q\x80`@\x01`@R\x80`\x13\x81R` \x01\x7F.genesis.difficulty\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x80Ta\x02\x91\x90a\x08\nV[`#\x81\x90UPa\x05\x1B`@Q\x80`@\x01`@R\x80`\x0F\x81R` \x01n\x0B\x99\xD9[\x99\\\xDA\\\xCB\x9A\x19ZY\xDA\x1D`\x8A\x1B\x81RP` \x80Ta\x02\x91\x90a\x08\nV[`$\x81\x90UPa\x05V`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k\x05\xCC\xEC\xAD\xCC\xAEm.e\xCD\x0C\xAF`\xA3\x1B\x81RP` \x80Ta\x01\xFB\x90a\x08\nV[`%\x90a\x05c\x90\x82a\x08\x8EV[Pa\t\xA7V[`@Qc\x1F\xB2C}`\xE3\x1B\x81R``\x90_Q` a}\xD2_9_Q\x90_R\x90c\xFD\x92\x1B\xE8\x90a\x05\x9E\x90\x86\x90\x86\x90`\x04\x01a\tlV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xB8W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x05\xDF\x91\x90\x81\x01\x90a\x07#V[\x93\x92PPPV[`@QcV\xEE\xF1[`\xE1\x1B\x81R_\x90_Q` a}\xD2_9_Q\x90_R\x90c\xAD\xDD\xE2\xB6\x90a\x06\x1A\x90\x86\x90\x86\x90`\x04\x01a\tlV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x065W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xDF\x91\x90a\t\x90V[`@Qc\x17w\xE5\x9D`\xE0\x1B\x81R_\x90_Q` a}\xD2_9_Q\x90_R\x90c\x17w\xE5\x9D\x90a\x06\x1A\x90\x86\x90\x86\x90`\x04\x01a\tlV[a);\x80aT\x97\x839\x01\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x80`\x01`\x01`@\x1B\x03\x84\x11\x15a\x06\xC7Wa\x06\xC7a\x06\x9AV[P`@Q`\x1F\x19`\x1F\x85\x01\x81\x16`?\x01\x16\x81\x01\x81\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17\x15a\x06\xF5Wa\x06\xF5a\x06\x9AV[`@R\x83\x81R\x90P\x80\x82\x84\x01\x85\x10\x15a\x07\x0CW__\xFD[\x83\x83` \x83\x01^_` \x85\x83\x01\x01RP\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x073W__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x07HW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x07XW__\xFD[a\x07g\x84\x82Q` \x84\x01a\x06\xAEV[\x94\x93PPPPV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x07\x91\x82\x85a\x07oV[\x7F/test/fullRelay/testData/\0\0\0\0\0\0\0\x81Ra\x07\xC1`\x19\x82\x01\x85a\x07oV[\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R_a\x05\xDF` \x83\x01\x84a\x07\xCAV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x08\x1EW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x08^<#\x11a\x01\x02W\x80c>^<#\x14a\x01\xD2W\x80c?r\x86\xF4\x14a\x01\xDAW\x80cD\xBA\xDB\xB6\x14a\x01\xE2W__\xFD[\x80c*\xDE8\x80\x14a\x01\xB5W\x80c,P=\x91\x14a\x01\xCAW__\xFD[\x80c\x06\xD5~3\x14a\x01MW\x80c\x08\x13\x85*\x14a\x01WW\x80c\x1C\r\xA8\x1F\x14a\x01\x80W\x80c\x1E\xD7\x83\x1C\x14a\x01\xA0W[__\xFD[a\x01Ua\x02\x99V[\0[a\x01ja\x01e6`\x04a\x19\x8DV[a\x03[V[`@Qa\x01w\x91\x90a\x1ABV[`@Q\x80\x91\x03\x90\xF3[a\x01\x93a\x01\x8E6`\x04a\x19\x8DV[a\x03\xA6V[`@Qa\x01w\x91\x90a\x1A\xA5V[a\x01\xA8a\x04\x18V[`@Qa\x01w\x91\x90a\x1A\xB7V[a\x01\xBDa\x04xV[`@Qa\x01w\x91\x90a\x1B\\V[a\x01Ua\x05\xB4V[a\x01\xA8a\x08\xE4V[a\x01\xA8a\tBV[a\x01\xF5a\x01\xF06`\x04a\x19\x8DV[a\t\xA0V[`@Qa\x01w\x91\x90a\x1B\xD3V[a\x02\na\t\xE3V[`@Qa\x01w\x91\x90a\x1CfV[a\x02\x1Fa\x0B\\V[`@Qa\x01w\x91\x90a\x1C\xE4V[a\x024a\x0C'V[`@Qa\x01w\x91\x90a\x1C\xF6V[a\x01Ua\r\x1DV[a\x024a\x0E9V[a\x02\x1Fa\x0F/V[a\x02aa\x0F\xFAV[`@Q\x90\x15\x15\x81R` \x01a\x01wV[a\x01\xA8a\x10\xCAV[`\x1FTa\x02a\x90`\xFF\x16\x81V[a\x01\xF5a\x02\x946`\x04a\x19\x8DV[a\x11(V[sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\xF2\x8D\xCE\xB3`@Q\x80``\x01`@R\x80`=\x81R` \x01aJq`=\x919`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x02\xF1\x91\x90a\x1A\xA5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x03\x08W__\xFD[PZ\xF1\x15\x80\x15a\x03\x1AW=__>=_\xFD[PPPP`%`$T`\"T`@Qa\x032\x90a\x18\xFBV[a\x03>\x93\x92\x91\x90a\x1D\xBEV[`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03WW=__>=_\xFD[PPV[``a\x03\x9E\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x11kV[\x94\x93PPPPV[``_a\x03\xB4\x85\x85\x85a\x03[V[\x90P_[a\x03\xC2\x85\x85a\x1E\xD7V[\x81\x10\x15a\x04\x0FW\x82\x82\x82\x81Q\x81\x10a\x03\xDCWa\x03\xDCa\x1E\xEAV[` \x02` \x01\x01Q`@Q` \x01a\x03\xF5\x92\x91\x90a\x1F.V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x03\xB8V[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04nW` \x02\x82\x01\x91\x90_R` _ \x90[\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04PW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05\xABW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x05\x94W\x83\x82\x90_R` _ \x01\x80Ta\x05\t\x90a\x1DmV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x055\x90a\x1DmV[\x80\x15a\x05\x80W\x80`\x1F\x10a\x05WWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05\x80V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05cW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x04\xECV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x04\x9BV[PPPP\x90P\x90V[a\x064`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16c\xE3\xD8\xD8\xD8`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06,\x91\x90a\x1FBV[`!Ta\x12\xCCV[a\x06\x88`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16c\x19\x10\xD9s`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\x08W=__>=_\xFD[a\x06\xDC`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16c\xC5\x82B\xCD`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\x08W=__>=_\xFD[`\x1FT`!T`@Q\x7F0\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\x81\x01\x91\x90\x91R_`$\x82\x01Ra\x07M\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90c0\x01{;\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\x08W=__>=_\xFD[`\x1FT`!T`@Q\x7F`\xB5\xC3\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\x81\x01\x91\x90\x91Ra\x07\xE4\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90c`\xB5\xC3\x90\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07\xB8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xDC\x91\x90a\x1FBV[`$Ta\x13PV[a\x08d`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16c\x117d\xBE`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x088W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\\\x91\x90a\x1FBV[`#Ta\x13PV[a\x08\xE2`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16c+\x97\xBE$`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\xB8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\xDC\x91\x90a\x1FBV[_a\x13PV[V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04nW` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04PWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04nW` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04PWPPPPP\x90P\x90V[``a\x03\x9E\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x13\xA8V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05\xABW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\n6\x90a\x1DmV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\nb\x90a\x1DmV[\x80\x15a\n\xADW\x80`\x1F\x10a\n\x84Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\xADV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\n\x90W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x0BDW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\n\xF1W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\n\x06V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05\xABW\x83\x82\x90_R` _ \x01\x80Ta\x0B\x9C\x90a\x1DmV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\xC8\x90a\x1DmV[\x80\x15a\x0C\x13W\x80`\x1F\x10a\x0B\xEAWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C\x13V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xF6W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0B\x7FV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05\xABW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\x05W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C\xB2W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0CJV[`@\x80Q\x80\x82\x01\x82R`\x11\x81R\x7FBad genesis block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\r\x9E\x91\x90`\x04\x01a\x1A\xA5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\r\xB5W__\xFD[PZ\xF1\x15\x80\x15a\r\xC7W=__>=_\xFD[PPPP`$T`\"T`@Qa\r\xDD\x90a\x18\xFBV[``\x80\x82R_\x90\x82\x01R` \x81\x01\x92\x90\x92R`@\x82\x01R`\x80\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x0E\x10W=__>=_\xFD[P`\x1F`\x01a\x01\0\n\x81T\x81`\x01`\x01`\xA0\x1B\x03\x02\x19\x16\x90\x83`\x01`\x01`\xA0\x1B\x03\x16\x02\x17\x90UPV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05\xABW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0F\x17W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0E\xC4W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0E\\V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05\xABW\x83\x82\x90_R` _ \x01\x80Ta\x0Fo\x90a\x1DmV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F\x9B\x90a\x1DmV[\x80\x15a\x0F\xE6W\x80`\x1F\x10a\x0F\xBDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F\xE6V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\xC9W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0FRV[`\x08T_\x90`\xFF\x16\x15a\x10\x11WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\xC3\x91\x90a\x1FBV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04nW` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04PWPPPPP\x90P\x90V[``a\x03\x9E\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x14\xF6V[``a\x11w\x84\x84a\x1E\xD7V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x11\x8FWa\x11\x8Fa\x19\x08V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x11\xC2W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x11\xADW\x90P[P\x90P\x83[\x83\x81\x10\x15a\x12\xC3Wa\x12\x95\x86a\x11\xDC\x83a\x16DV[\x85`@Q` \x01a\x11\xEF\x93\x92\x91\x90a\x1FYV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x12\x0B\x90a\x1DmV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x127\x90a\x1DmV[\x80\x15a\x12\x82W\x80`\x1F\x10a\x12YWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x12\x82V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x12eW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x17u\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x12\xA0\x87\x84a\x1E\xD7V[\x81Q\x81\x10a\x12\xB0Wa\x12\xB0a\x1E\xEAV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x11\xC7V[P\x94\x93PPPPV[`@Q\x7F|\x84\xC6\x9B\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c|\x84\xC6\x9B\x90`D\x01[_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x136W__\xFD[PZ\xFA\x15\x80\x15a\x13HW=__>=_\xFD[PPPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01a\x13 V[``a\x13\xB4\x84\x84a\x1E\xD7V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x13\xCCWa\x13\xCCa\x19\x08V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x13\xF5W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x12\xC3Wa\x14\xC8\x86a\x14\x0F\x83a\x16DV[\x85`@Q` \x01a\x14\"\x93\x92\x91\x90a\x1FYV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x14>\x90a\x1DmV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x14j\x90a\x1DmV[\x80\x15a\x14\xB5W\x80`\x1F\x10a\x14\x8CWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x14\xB5V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x14\x98W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x18\x14\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x14\xD3\x87\x84a\x1E\xD7V[\x81Q\x81\x10a\x14\xE3Wa\x14\xE3a\x1E\xEAV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x13\xFAV[``a\x15\x02\x84\x84a\x1E\xD7V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x15\x1AWa\x15\x1Aa\x19\x08V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x15CW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x12\xC3Wa\x16\x16\x86a\x15]\x83a\x16DV[\x85`@Q` \x01a\x15p\x93\x92\x91\x90a\x1FYV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x15\x8C\x90a\x1DmV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x15\xB8\x90a\x1DmV[\x80\x15a\x16\x03W\x80`\x1F\x10a\x15\xDAWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x16\x03V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15\xE6W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x18\xA7\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x16!\x87\x84a\x1E\xD7V[\x81Q\x81\x10a\x161Wa\x161a\x1E\xEAV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x15HV[``\x81_\x03a\x16\x86WPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x16\xAFW\x80a\x16\x99\x81a\x1F\xF6V[\x91Pa\x16\xA8\x90P`\n\x83a ZV[\x91Pa\x16\x89V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\xC9Wa\x16\xC9a\x19\x08V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x16\xF3W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x03\x9EWa\x17\x08`\x01\x83a\x1E\xD7V[\x91Pa\x17\x15`\n\x86a mV[a\x17 \x90`0a \x80V[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x175Wa\x175a\x1E\xEAV[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x17n`\n\x86a ZV[\x94Pa\x16\xF7V[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a\x17\xCA\x90\x86\x90\x86\x90`\x04\x01a \x93V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x17\xE4W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x18\x0B\x91\x90\x81\x01\x90a \xC0V[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x18h\x90\x86\x90\x86\x90`\x04\x01a \x93V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x18\x83W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x18\x0B\x91\x90a\x1FBV[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x18h\x90\x86\x90\x86\x90`\x04\x01a \x93V[a);\x80a!6\x839\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`A`\x04R`$_\xFD[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x19^Wa\x19^a\x19\x08V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x19\x7FWa\x19\x7Fa\x19\x08V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x19\x9FW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x19\xB5W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x19\xC5W__\xFD[\x805a\x19\xD8a\x19\xD3\x82a\x19fV[a\x195V[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x19\xECW__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1A\x99W`?\x19\x87\x86\x03\x01\x84Ra\x1A\x84\x85\x83Qa\x1A\x14V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1AhV[P\x92\x96\x95PPPPPPV[` \x81R_a\x18\x0B` \x83\x01\x84a\x1A\x14V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1A\xF7W\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1A\xD0V[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x1BPW`\x1F\x19\x85\x84\x03\x01\x88Ra\x1B:\x83\x83Qa\x1A\x14V[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x1B\x1EV[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1A\x99W`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1B\xBD`@\x87\x01\x82a\x1B\x02V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1B\x82V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1A\xF7W\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1B\xECV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x1C\\W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x1C\x1CV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1A\x99W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x1C\xB2`@\x88\x01\x82a\x1A\x14V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x1C\xCD\x81\x83a\x1C\nV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1C\x8CV[` \x81R_a\x18\x0B` \x83\x01\x84a\x1B\x02V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1A\x99W`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1DW`@\x87\x01\x82a\x1C\nV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1D\x1CV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1D\x81W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x1D\xB8W\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[P\x91\x90PV[``\x81R__\x85T_\x81`\x01\x1C\x90P`\x01\x82\x16\x80a\x1D\xDDW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x1E\x14W\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[``\x86\x01\x82\x90R`\x80\x86\x01\x81\x80\x15a\x1E3W`\x01\x81\x14a\x1EgWa\x1E\x93V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x85\x16\x82R\x83\x15\x15`\x05\x1B\x82\x01\x95Pa\x1E\x93V[_\x8B\x81R` \x90 _[\x85\x81\x10\x15a\x1E\x8DW\x81T\x84\x82\x01R`\x01\x90\x91\x01\x90` \x01a\x1EqV[\x83\x01\x96PP[PPPPP` \x83\x01\x94\x90\x94RP`@\x01R\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[\x81\x81\x03\x81\x81\x11\x15a\x18\x0EWa\x18\x0Ea\x1E\xAAV[\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x03\x9Ea\x1F<\x83\x86a\x1F\x17V[\x84a\x1F\x17V[_` \x82\x84\x03\x12\x15a\x1FRW__\xFD[PQ\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\x81R_a\x1F\x8A`\x01\x83\x01\x86a\x1F\x17V[\x7F[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x1F\xBA`\x01\x82\x01\x86a\x1F\x17V[\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\x81Ra\x1F\xEC`\x02\x82\x01\x85a\x1F\x17V[\x96\x95PPPPPPV[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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 &Wa &a\x1E\xAAV[P`\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`\x12`\x04R`$_\xFD[_\x82a hWa ha -V[P\x04\x90V[_\x82a {Wa {a -V[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a\x18\x0EWa\x18\x0Ea\x1E\xAAV[`@\x81R_a \xA5`@\x83\x01\x85a\x1A\x14V[\x82\x81\x03` \x84\x01Ra \xB7\x81\x85a\x1A\x14V[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a \xD0W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a \xE6W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a \xF6W__\xFD[\x80Qa!\x04a\x19\xD3\x82a\x19fV[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a!\x18W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa);8\x03\x80a);\x839\x81\x01`@\x81\x90Ra\0.\x91a\x03+V[\x82\x82\x82\x82\x82\x82a\0?\x83Q`P\x14\x90V[a\0\x84W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x11`$\x82\x01RpBad genesis block`x\x1B`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\0\x8E\x84a\x01fV[\x90Pb\xFF\xFF\xFF\x82\x16\x15a\x01\tW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FPeriod start hash does not have `D\x82\x01R\x7Fwork. Hint: wrong byte order?\0\0\0`d\x82\x01R`\x84\x01a\0{V[_\x81\x81U`\x01\x82\x90U`\x02\x82\x90U\x81\x81R`\x04` R`@\x90 \x83\x90Ua\x012a\x07\xE0\x84a\x03\xFEV[a\x01<\x90\x84a\x04%V[_\x83\x81R`\x04` R`@\x90 Ua\x01S\x84a\x02&V[`\x05UPa\x05\xBD\x98PPPPPPPPPV[_`\x02\x80\x83`@Qa\x01x\x91\x90a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\x93W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x04NV[`@Q` \x01a\x01\xC8\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x01\xE2\x91a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\xFDW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02 \x91\x90a\x04NV[\x92\x91PPV[_a\x02 a\x023\x83a\x028V[a\x02CV[_a\x02 \x82\x82a\x02SV[_a\x02 a\xFF\xFF`\xD0\x1B\x83a\x02\xF7V[_\x80a\x02ja\x02c\x84`Ha\x04eV[\x85\x90a\x03\tV[`\xE8\x1C\x90P_\x84a\x02|\x85`Ka\x04eV[\x81Q\x81\x10a\x02\x8CWa\x02\x8Ca\x04xV[\x01` \x01Q`\xF8\x1C\x90P_a\x02\xBE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x02\xD1`\x03\x84a\x04\x8CV[`\xFF\x16\x90Pa\x02\xE2\x81a\x01\0a\x05\x88V[a\x02\xEC\x90\x83a\x05\x93V[\x97\x96PPPPPPPV[_a\x03\x02\x82\x84a\x05\xAAV[\x93\x92PPPV[_a\x03\x02\x83\x83\x01` \x01Q\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x03=W__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03RW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03bW__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03{Wa\x03{a\x03\x17V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x03\xA9Wa\x03\xA9a\x03\x17V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x03\xC0W__\xFD[\x81` \x84\x01` \x83\x01^_` \x92\x82\x01\x83\x01R\x90\x86\x01Q`@\x90\x96\x01Q\x90\x97\x95\x96P\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x04\x0CWa\x04\x0Ca\x03\xEAV[P\x06\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x04^W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02 Wa\x02 a\x04\x11V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[`\x01\x81[`\x01\x84\x11\x15a\x04\xE0W\x80\x85\x04\x81\x11\x15a\x04\xC4Wa\x04\xC4a\x04\x11V[`\x01\x84\x16\x15a\x04\xD2W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x04\xA9V[\x93P\x93\x91PPV[_\x82a\x04\xF6WP`\x01a\x02 V[\x81a\x05\x02WP_a\x02 V[\x81`\x01\x81\x14a\x05\x18W`\x02\x81\x14a\x05\"Wa\x05>V[`\x01\x91PPa\x02 V[`\xFF\x84\x11\x15a\x053Wa\x053a\x04\x11V[PP`\x01\x82\x1Ba\x02 V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x05aWP\x81\x81\na\x02 V[a\x05m_\x19\x84\x84a\x04\xA5V[\x80_\x19\x04\x82\x11\x15a\x05\x80Wa\x05\x80a\x04\x11V[\x02\x93\x92PPPV[_a\x03\x02\x83\x83a\x04\xE8V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x02 Wa\x02 a\x04\x11V[_\x82a\x05\xB8Wa\x05\xB8a\x03\xEAV[P\x04\x90V[a#q\x80a\x05\xCA_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\xADW\x80c\xB9\x85b\x1A\x11a\0}W\x80c\xE3\xD8\xD8\xD8\x11a\0cW\x80c\xE3\xD8\xD8\xD8\x14a\x02\"W\x80c\xE4q\xE7,\x14a\x02)W\x80c\xF5\x8D\xB0o\x14a\x02=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x13\x91\x90a!WV[`@Q` \x01a\x0C%\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\x90\x82\x90Ra\x0C]\x91a!AV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0CxW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x07\x91\x90a!WV[_\x83\x85\x14\x80\x15a\x0C\xAAWP\x82\x85\x14[\x15a\x0C\xB7WP`\x01a\x04\xF1V[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x0C\xFFW\x89\x83\x14a\x0C\xDEW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x0C\xF7W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x0C\xBDV[P\x82\x84\x03a\r\x13W_\x94PPPPPa\x04\xF1V[\x80\x82\x14a\r&W_\x94PPPPPa\x04\xF1V[P`\x01\x98\x97PPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\rYW_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\r9V[P\x80a\x05\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x80\x82\x81[a\r\xB8`\x04`\x01a!\x9BV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0E\x0CW_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\r\xF1W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0E\x04V[a\r\xFB\x81\x84a!\xB7V[\x95\x94PPPPPV[`\x01\x01a\r\xACV[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_`P\x82Qa\x0B~\x91\x90a!.V[__a\x0Eo\x85a\x0B\xC3V[\x90P_a\x0E{\x82a\r\xA7V[\x90P_a\x0E\x87\x86a\x19\xE6V[\x90P\x84\x80a\x0E\x9CWP\x80a\x0E\x9A\x88a\x19\xE6V[\x14[a\x0F\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x03.V[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x12\x0EWa\x0F(`P\x82a!\xCAV[a\x0F3\x90`\x01a!\xB7V[a\x0F=\x90\x87a!\xB7V[\x93Pa\x0FK\x8A\x82`Pa\x19\xF1V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x11!W\x84a\x10\xA1\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x10\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x11\n`\x04\x85a!.V[_\x03a\x11!W_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x11,\x8B\x83a\x1A\x16V[\x14a\x11yW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[\x86a\x11\x84\x8B\x83a\x1A\xAFV[\x14a\x11\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x03.V[\x82\x96P`P\x81a\x12\x07\x91\x90a!\xB7V[\x90Pa\x0F\x15V[P\x81a\x12\x19\x8Ba\x0B\xC3V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x12\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x12\xD4\x84a\x0B\xC3V[\x90P_a\x12\xE0\x86a\x0B\xC3V[\x90P`\x01T\x81\x14a\x133W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x03.V[_\x82\x81R`\x03` R`@\x90 Ta\x13\x8DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x13\x9B\x87`\x01T\x84\x87a\x0C\x9BV[a\x14\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x03.V[\x81a\x14\x19\x88\x88\x88a\x17\x80V[\x14a\x14\x8CW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[`\x01\x82\x90U`\x02\x87\x90U_a\x14\xA0\x86a\x1A\xC7V[\x90P`\x05T\x81\x14a\x14\xB1W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x15\x01a\x14\xFC\x86a\x0B\xC3V[a\r\xA7V[\x90P_a\x15\x10a\x14\xFC\x86a\x0B\xC3V[\x90Pa\x15\x1Ea\x07\xE0\x82a!.V[a\x07\xDF\x14a\x15\x94W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x03.V[a\x15\xA0\x82a\x07\xDFa!\xB7V[\x81\x14a\x16\x14W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x03.V[a\x16\x1D\x85a\x1A\xC7V[a\x16&\x87a\x1A\xC7V[\x14a\x16\x99W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x03.V[_a\x16\xA3\x85a\x19\xE6V[\x90P_a\x16\xD5a\x16\xB2\x89a\x19\xE6V[a\x16\xBB\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x16\xCA\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x1B\x0CV[\x90P\x81\x81\x83\x16\x14a\x17(W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_a\x172\x89a\x1A\xC7V[\x90P\x80`\x06T\x14\x15\x80\x15a\x17\\WPa\x07\xE0a\x17O`\x01Ta\r\xA7V[a\x17Y\x91\x90a!\xDDV[\x84\x11[\x15a\x17gW`\x06\x81\x90U[a\x17s\x88\x88`\x01a\x0EdV[\x99\x98PPPPPPPPPV[__a\x17\x8B\x85a\r\xA7V[\x90P_a\x17\x9Aa\x14\xFC\x86a\x0B\xC3V[\x90P_a\x17\xA9a\x14\xFC\x86a\x0B\xC3V[\x90P\x82\x82\x10\x15\x80\x15a\x17\xBBWP\x82\x81\x10\x15[a\x18-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x18:a\x07\xE0\x85a!.V[a\x18F\x85a\x07\xE0a!\xB7V[a\x18P\x91\x90a!\xDDV[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x18bWP\x80[\x15a\x18}Wa\x18p\x89a\x0B\xC3V[\x96PPPPPPPa\n\xA3V[\x81\x80\x15a\x18\x88WP\x80\x15[\x15a\x18\x96Wa\x18p\x88a\x0B\xC3V[\x81\x80\x15a\x18\xA0WP\x80[\x15a\x18\xC4W\x83\x85\x10\x15a\x18\xBBWa\x18\xB6\x88a\x0B\xC3V[a\x18pV[a\x18p\x89a\x0B\xC3V[a\x18\xCD\x88a\x1A\xC7V[a\x18\xD9a\x07\xE0\x86a!.V[a\x18\xE3\x91\x90a!\xF0V[a\x18\xEC\x8Aa\x1A\xC7V[a\x18\xF8a\x07\xE0\x88a!.V[a\x19\x02\x91\x90a!\xF0V[\x10\x15a\x18\xBBWa\x18p\x88a\x0B\xC3V[`\x07T_\x90`\xFF\x16\x15a\x19/WP`\x07Ta\x01\0\x90\x04`\xFF\x16a\n\xA3V[a\x19:\x84\x84\x84a\x1B\x94V[\x90Pa\n\xA3V[_` \x84Qa\x19P\x91\x90a!.V[\x15a\x19\\WP_a\x04\xF1V[\x83Q_\x03a\x19kWP_a\x04\xF1V[\x81\x85_[\x86Q\x81\x10\x15a\x19\xD9Wa\x19\x83`\x02\x84a!.V[`\x01\x03a\x19\xA7Wa\x19\xA0a\x19\x9A\x88\x83\x01` \x01Q\x90V[\x83a\x1B\xD5V[\x91Pa\x19\xC0V[a\x19\xBD\x82a\x19\xB8\x89\x84\x01` \x01Q\x90V[a\x1B\xD5V[\x91P[`\x01\x92\x90\x92\x1C\x91a\x19\xD2` \x82a!\xB7V[\x90Pa\x19oV[P\x90\x93\x14\x95\x94PPPPPV[_a\x05\x07\x82_a\x1A\x16V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x1A-a\x1A&\x84`Ha!\xB7V[\x85\x90a\x1B\xE0V[`\xE8\x1C\x90P_\x84a\x1A?\x85`Ka!\xB7V[\x81Q\x81\x10a\x1AOWa\x1AOa\"\x07V[\x01` \x01Q`\xF8\x1C\x90P_a\x1A\x81\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1A\x94`\x03\x84a\"4V[`\xFF\x16\x90Pa\x1A\xA5\x81a\x01\0a#0V[a\x08-\x90\x83a!\xF0V[_a\x05\x04a\x1A\xBE\x83`\x04a!\xB7V[\x84\x01` \x01Q\x90V[_a\x05\x07a\x1A\xD4\x83a\x19\xE6V[a\x1B\xEEV[_a\x05\x07a\x1A\xE6\x83a\x1C\x15V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1B\x18\x83\x85a\x1C!V[\x90Pa\x1B(b\x12u\0`\x04a\x1C|V[\x81\x10\x15a\x1B@Wa\x1B=b\x12u\0`\x04a\x1C|V[\x90P[a\x1BNb\x12u\0`\x04a\x1C\x87V[\x81\x11\x15a\x1BfWa\x1Bcb\x12u\0`\x04a\x1C\x87V[\x90P[_a\x1B~\x82a\x1Bx\x88b\x01\0\0a\x1C|V[\x90a\x1C\x87V[\x90Pa\n\x8Ab\x01\0\0a\x1Bx\x83b\x12u\0a\x1C|V[_\x82\x81[\x83\x81\x10\x15a\x1B\xCAW\x85\x82\x03a\x1B\xB2W`\x01\x92PPPa\n\xA3V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x1B\x98V[P_\x95\x94PPPPPV[_a\x05\x04\x83\x83a\x1C\xFAV[_a\x05\x04\x83\x83\x01` \x01Q\x90V[_a\x05\x07{\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\x83a\x1C|V[_a\x05\x07\x82`Da\x1B\xE0V[_\x82\x82\x11\x15a\x1CrW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x05\x04\x82\x84a!\xDDV[_a\x05\x04\x82\x84a!\xCAV[_\x82_\x03a\x1C\x96WP_a\x05\x07V[a\x1C\xA0\x82\x84a!\xF0V[\x90P\x81a\x1C\xAD\x84\x83a!\xCAV[\x14a\x05\x07W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x03.V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1D1W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DHW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1D_W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1DvW__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1D\x91W__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xA7W__\xFD[a\x1D\xB3\x8A\x82\x8B\x01a\x1D!V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xD2W__\xFD[a\x1D\xDE\x8A\x82\x8B\x01a\x1D!V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1D\xFE`\x80\x89\x01a\x1DfV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[____`\x80\x85\x87\x03\x12\x15a\x1E\x1FW__\xFD[PP\x825\x94` \x84\x015\x94P`@\x84\x015\x93``\x015\x92P\x90PV[__`@\x83\x85\x03\x12\x15a\x1ELW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1EkW__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1E\x85W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x9BW__\xFD[a\x1E\xA7\x87\x82\x88\x01a\x1D!V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\xC6W__\xFD[a\x1E\xD2\x87\x82\x88\x01a\x1D!V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1E\xF3W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x10W__\xFD[a\x1F\x1C\x89\x82\x8A\x01a\x1D!V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F;W__\xFD[a\x1FG\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1FtW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x8AW__\xFD[a\x1F\x96\x89\x82\x8A\x01a\x1D!V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xB5W__\xFD[a\x1F\xC1\x89\x82\x8A\x01a\x1D!V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xE0W__\xFD[a\x1F\xEC\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_____``\x86\x88\x03\x12\x15a \x12W__\xFD[\x855\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a /W__\xFD[a ;\x88\x82\x89\x01a\x1D!V[\x90\x95P\x93PP`@\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a ZW__\xFD[a f\x88\x82\x89\x01a\x1D!V[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[___``\x84\x86\x03\x12\x15a \x89W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a \xB1W__\xFD[\x825\x91Pa \xC1` \x84\x01a\x1DfV[\x90P\x92P\x92\x90PV[\x805\x80\x15\x15\x81\x14a\x1DvW__\xFD[__`@\x83\x85\x03\x12\x15a \xEAW__\xFD[a \xF3\x83a \xCAV[\x91Pa \xC1` \x84\x01a \xCAV[\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!=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x04NV[`@Q` \x01a\x01\xC8\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x01\xE2\x91a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\xFDW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02 \x91\x90a\x04NV[\x92\x91PPV[_a\x02 a\x023\x83a\x028V[a\x02CV[_a\x02 \x82\x82a\x02SV[_a\x02 a\xFF\xFF`\xD0\x1B\x83a\x02\xF7V[_\x80a\x02ja\x02c\x84`Ha\x04eV[\x85\x90a\x03\tV[`\xE8\x1C\x90P_\x84a\x02|\x85`Ka\x04eV[\x81Q\x81\x10a\x02\x8CWa\x02\x8Ca\x04xV[\x01` \x01Q`\xF8\x1C\x90P_a\x02\xBE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x02\xD1`\x03\x84a\x04\x8CV[`\xFF\x16\x90Pa\x02\xE2\x81a\x01\0a\x05\x88V[a\x02\xEC\x90\x83a\x05\x93V[\x97\x96PPPPPPPV[_a\x03\x02\x82\x84a\x05\xAAV[\x93\x92PPPV[_a\x03\x02\x83\x83\x01` \x01Q\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x03=W__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03RW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03bW__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03{Wa\x03{a\x03\x17V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x03\xA9Wa\x03\xA9a\x03\x17V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x03\xC0W__\xFD[\x81` \x84\x01` \x83\x01^_` \x92\x82\x01\x83\x01R\x90\x86\x01Q`@\x90\x96\x01Q\x90\x97\x95\x96P\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x04\x0CWa\x04\x0Ca\x03\xEAV[P\x06\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x04^W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02 Wa\x02 a\x04\x11V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[`\x01\x81[`\x01\x84\x11\x15a\x04\xE0W\x80\x85\x04\x81\x11\x15a\x04\xC4Wa\x04\xC4a\x04\x11V[`\x01\x84\x16\x15a\x04\xD2W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x04\xA9V[\x93P\x93\x91PPV[_\x82a\x04\xF6WP`\x01a\x02 V[\x81a\x05\x02WP_a\x02 V[\x81`\x01\x81\x14a\x05\x18W`\x02\x81\x14a\x05\"Wa\x05>V[`\x01\x91PPa\x02 V[`\xFF\x84\x11\x15a\x053Wa\x053a\x04\x11V[PP`\x01\x82\x1Ba\x02 V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x05aWP\x81\x81\na\x02 V[a\x05m_\x19\x84\x84a\x04\xA5V[\x80_\x19\x04\x82\x11\x15a\x05\x80Wa\x05\x80a\x04\x11V[\x02\x93\x92PPPV[_a\x03\x02\x83\x83a\x04\xE8V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x02 Wa\x02 a\x04\x11V[_\x82a\x05\xB8Wa\x05\xB8a\x03\xEAV[P\x04\x90V[a#q\x80a\x05\xCA_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\xADW\x80c\xB9\x85b\x1A\x11a\0}W\x80c\xE3\xD8\xD8\xD8\x11a\0cW\x80c\xE3\xD8\xD8\xD8\x14a\x02\"W\x80c\xE4q\xE7,\x14a\x02)W\x80c\xF5\x8D\xB0o\x14a\x02=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x13\x91\x90a!WV[`@Q` \x01a\x0C%\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\x90\x82\x90Ra\x0C]\x91a!AV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0CxW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x07\x91\x90a!WV[_\x83\x85\x14\x80\x15a\x0C\xAAWP\x82\x85\x14[\x15a\x0C\xB7WP`\x01a\x04\xF1V[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x0C\xFFW\x89\x83\x14a\x0C\xDEW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x0C\xF7W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x0C\xBDV[P\x82\x84\x03a\r\x13W_\x94PPPPPa\x04\xF1V[\x80\x82\x14a\r&W_\x94PPPPPa\x04\xF1V[P`\x01\x98\x97PPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\rYW_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\r9V[P\x80a\x05\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x80\x82\x81[a\r\xB8`\x04`\x01a!\x9BV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0E\x0CW_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\r\xF1W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0E\x04V[a\r\xFB\x81\x84a!\xB7V[\x95\x94PPPPPV[`\x01\x01a\r\xACV[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_`P\x82Qa\x0B~\x91\x90a!.V[__a\x0Eo\x85a\x0B\xC3V[\x90P_a\x0E{\x82a\r\xA7V[\x90P_a\x0E\x87\x86a\x19\xE6V[\x90P\x84\x80a\x0E\x9CWP\x80a\x0E\x9A\x88a\x19\xE6V[\x14[a\x0F\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x03.V[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x12\x0EWa\x0F(`P\x82a!\xCAV[a\x0F3\x90`\x01a!\xB7V[a\x0F=\x90\x87a!\xB7V[\x93Pa\x0FK\x8A\x82`Pa\x19\xF1V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x11!W\x84a\x10\xA1\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x10\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x11\n`\x04\x85a!.V[_\x03a\x11!W_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x11,\x8B\x83a\x1A\x16V[\x14a\x11yW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[\x86a\x11\x84\x8B\x83a\x1A\xAFV[\x14a\x11\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x03.V[\x82\x96P`P\x81a\x12\x07\x91\x90a!\xB7V[\x90Pa\x0F\x15V[P\x81a\x12\x19\x8Ba\x0B\xC3V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x12\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x12\xD4\x84a\x0B\xC3V[\x90P_a\x12\xE0\x86a\x0B\xC3V[\x90P`\x01T\x81\x14a\x133W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x03.V[_\x82\x81R`\x03` R`@\x90 Ta\x13\x8DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x13\x9B\x87`\x01T\x84\x87a\x0C\x9BV[a\x14\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x03.V[\x81a\x14\x19\x88\x88\x88a\x17\x80V[\x14a\x14\x8CW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[`\x01\x82\x90U`\x02\x87\x90U_a\x14\xA0\x86a\x1A\xC7V[\x90P`\x05T\x81\x14a\x14\xB1W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x15\x01a\x14\xFC\x86a\x0B\xC3V[a\r\xA7V[\x90P_a\x15\x10a\x14\xFC\x86a\x0B\xC3V[\x90Pa\x15\x1Ea\x07\xE0\x82a!.V[a\x07\xDF\x14a\x15\x94W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x03.V[a\x15\xA0\x82a\x07\xDFa!\xB7V[\x81\x14a\x16\x14W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x03.V[a\x16\x1D\x85a\x1A\xC7V[a\x16&\x87a\x1A\xC7V[\x14a\x16\x99W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x03.V[_a\x16\xA3\x85a\x19\xE6V[\x90P_a\x16\xD5a\x16\xB2\x89a\x19\xE6V[a\x16\xBB\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x16\xCA\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x1B\x0CV[\x90P\x81\x81\x83\x16\x14a\x17(W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_a\x172\x89a\x1A\xC7V[\x90P\x80`\x06T\x14\x15\x80\x15a\x17\\WPa\x07\xE0a\x17O`\x01Ta\r\xA7V[a\x17Y\x91\x90a!\xDDV[\x84\x11[\x15a\x17gW`\x06\x81\x90U[a\x17s\x88\x88`\x01a\x0EdV[\x99\x98PPPPPPPPPV[__a\x17\x8B\x85a\r\xA7V[\x90P_a\x17\x9Aa\x14\xFC\x86a\x0B\xC3V[\x90P_a\x17\xA9a\x14\xFC\x86a\x0B\xC3V[\x90P\x82\x82\x10\x15\x80\x15a\x17\xBBWP\x82\x81\x10\x15[a\x18-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x18:a\x07\xE0\x85a!.V[a\x18F\x85a\x07\xE0a!\xB7V[a\x18P\x91\x90a!\xDDV[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x18bWP\x80[\x15a\x18}Wa\x18p\x89a\x0B\xC3V[\x96PPPPPPPa\n\xA3V[\x81\x80\x15a\x18\x88WP\x80\x15[\x15a\x18\x96Wa\x18p\x88a\x0B\xC3V[\x81\x80\x15a\x18\xA0WP\x80[\x15a\x18\xC4W\x83\x85\x10\x15a\x18\xBBWa\x18\xB6\x88a\x0B\xC3V[a\x18pV[a\x18p\x89a\x0B\xC3V[a\x18\xCD\x88a\x1A\xC7V[a\x18\xD9a\x07\xE0\x86a!.V[a\x18\xE3\x91\x90a!\xF0V[a\x18\xEC\x8Aa\x1A\xC7V[a\x18\xF8a\x07\xE0\x88a!.V[a\x19\x02\x91\x90a!\xF0V[\x10\x15a\x18\xBBWa\x18p\x88a\x0B\xC3V[`\x07T_\x90`\xFF\x16\x15a\x19/WP`\x07Ta\x01\0\x90\x04`\xFF\x16a\n\xA3V[a\x19:\x84\x84\x84a\x1B\x94V[\x90Pa\n\xA3V[_` \x84Qa\x19P\x91\x90a!.V[\x15a\x19\\WP_a\x04\xF1V[\x83Q_\x03a\x19kWP_a\x04\xF1V[\x81\x85_[\x86Q\x81\x10\x15a\x19\xD9Wa\x19\x83`\x02\x84a!.V[`\x01\x03a\x19\xA7Wa\x19\xA0a\x19\x9A\x88\x83\x01` \x01Q\x90V[\x83a\x1B\xD5V[\x91Pa\x19\xC0V[a\x19\xBD\x82a\x19\xB8\x89\x84\x01` \x01Q\x90V[a\x1B\xD5V[\x91P[`\x01\x92\x90\x92\x1C\x91a\x19\xD2` \x82a!\xB7V[\x90Pa\x19oV[P\x90\x93\x14\x95\x94PPPPPV[_a\x05\x07\x82_a\x1A\x16V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x1A-a\x1A&\x84`Ha!\xB7V[\x85\x90a\x1B\xE0V[`\xE8\x1C\x90P_\x84a\x1A?\x85`Ka!\xB7V[\x81Q\x81\x10a\x1AOWa\x1AOa\"\x07V[\x01` \x01Q`\xF8\x1C\x90P_a\x1A\x81\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1A\x94`\x03\x84a\"4V[`\xFF\x16\x90Pa\x1A\xA5\x81a\x01\0a#0V[a\x08-\x90\x83a!\xF0V[_a\x05\x04a\x1A\xBE\x83`\x04a!\xB7V[\x84\x01` \x01Q\x90V[_a\x05\x07a\x1A\xD4\x83a\x19\xE6V[a\x1B\xEEV[_a\x05\x07a\x1A\xE6\x83a\x1C\x15V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1B\x18\x83\x85a\x1C!V[\x90Pa\x1B(b\x12u\0`\x04a\x1C|V[\x81\x10\x15a\x1B@Wa\x1B=b\x12u\0`\x04a\x1C|V[\x90P[a\x1BNb\x12u\0`\x04a\x1C\x87V[\x81\x11\x15a\x1BfWa\x1Bcb\x12u\0`\x04a\x1C\x87V[\x90P[_a\x1B~\x82a\x1Bx\x88b\x01\0\0a\x1C|V[\x90a\x1C\x87V[\x90Pa\n\x8Ab\x01\0\0a\x1Bx\x83b\x12u\0a\x1C|V[_\x82\x81[\x83\x81\x10\x15a\x1B\xCAW\x85\x82\x03a\x1B\xB2W`\x01\x92PPPa\n\xA3V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x1B\x98V[P_\x95\x94PPPPPV[_a\x05\x04\x83\x83a\x1C\xFAV[_a\x05\x04\x83\x83\x01` \x01Q\x90V[_a\x05\x07{\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\x83a\x1C|V[_a\x05\x07\x82`Da\x1B\xE0V[_\x82\x82\x11\x15a\x1CrW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x05\x04\x82\x84a!\xDDV[_a\x05\x04\x82\x84a!\xCAV[_\x82_\x03a\x1C\x96WP_a\x05\x07V[a\x1C\xA0\x82\x84a!\xF0V[\x90P\x81a\x1C\xAD\x84\x83a!\xCAV[\x14a\x05\x07W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x03.V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1D1W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DHW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1D_W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1DvW__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1D\x91W__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xA7W__\xFD[a\x1D\xB3\x8A\x82\x8B\x01a\x1D!V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xD2W__\xFD[a\x1D\xDE\x8A\x82\x8B\x01a\x1D!V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1D\xFE`\x80\x89\x01a\x1DfV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[____`\x80\x85\x87\x03\x12\x15a\x1E\x1FW__\xFD[PP\x825\x94` \x84\x015\x94P`@\x84\x015\x93``\x015\x92P\x90PV[__`@\x83\x85\x03\x12\x15a\x1ELW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1EkW__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1E\x85W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x9BW__\xFD[a\x1E\xA7\x87\x82\x88\x01a\x1D!V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\xC6W__\xFD[a\x1E\xD2\x87\x82\x88\x01a\x1D!V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1E\xF3W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x10W__\xFD[a\x1F\x1C\x89\x82\x8A\x01a\x1D!V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F;W__\xFD[a\x1FG\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1FtW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x8AW__\xFD[a\x1F\x96\x89\x82\x8A\x01a\x1D!V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xB5W__\xFD[a\x1F\xC1\x89\x82\x8A\x01a\x1D!V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xE0W__\xFD[a\x1F\xEC\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_____``\x86\x88\x03\x12\x15a \x12W__\xFD[\x855\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a /W__\xFD[a ;\x88\x82\x89\x01a\x1D!V[\x90\x95P\x93PP`@\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a ZW__\xFD[a f\x88\x82\x89\x01a\x1D!V[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[___``\x84\x86\x03\x12\x15a \x89W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a \xB1W__\xFD[\x825\x91Pa \xC1` \x84\x01a\x1DfV[\x90P\x92P\x92\x90PV[\x805\x80\x15\x15\x81\x14a\x1DvW__\xFD[__`@\x83\x85\x03\x12\x15a \xEAW__\xFD[a \xF3\x83a \xCAV[\x91Pa \xC1` \x84\x01a \xCAV[\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!^<#\x11a\x01\x02W\x80c>^<#\x14a\x01\xD2W\x80c?r\x86\xF4\x14a\x01\xDAW\x80cD\xBA\xDB\xB6\x14a\x01\xE2W__\xFD[\x80c*\xDE8\x80\x14a\x01\xB5W\x80c,P=\x91\x14a\x01\xCAW__\xFD[\x80c\x06\xD5~3\x14a\x01MW\x80c\x08\x13\x85*\x14a\x01WW\x80c\x1C\r\xA8\x1F\x14a\x01\x80W\x80c\x1E\xD7\x83\x1C\x14a\x01\xA0W[__\xFD[a\x01Ua\x02\x99V[\0[a\x01ja\x01e6`\x04a\x19\x8DV[a\x03[V[`@Qa\x01w\x91\x90a\x1ABV[`@Q\x80\x91\x03\x90\xF3[a\x01\x93a\x01\x8E6`\x04a\x19\x8DV[a\x03\xA6V[`@Qa\x01w\x91\x90a\x1A\xA5V[a\x01\xA8a\x04\x18V[`@Qa\x01w\x91\x90a\x1A\xB7V[a\x01\xBDa\x04xV[`@Qa\x01w\x91\x90a\x1B\\V[a\x01Ua\x05\xB4V[a\x01\xA8a\x08\xE4V[a\x01\xA8a\tBV[a\x01\xF5a\x01\xF06`\x04a\x19\x8DV[a\t\xA0V[`@Qa\x01w\x91\x90a\x1B\xD3V[a\x02\na\t\xE3V[`@Qa\x01w\x91\x90a\x1CfV[a\x02\x1Fa\x0B\\V[`@Qa\x01w\x91\x90a\x1C\xE4V[a\x024a\x0C'V[`@Qa\x01w\x91\x90a\x1C\xF6V[a\x01Ua\r\x1DV[a\x024a\x0E9V[a\x02\x1Fa\x0F/V[a\x02aa\x0F\xFAV[`@Q\x90\x15\x15\x81R` \x01a\x01wV[a\x01\xA8a\x10\xCAV[`\x1FTa\x02a\x90`\xFF\x16\x81V[a\x01\xF5a\x02\x946`\x04a\x19\x8DV[a\x11(V[sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\xF2\x8D\xCE\xB3`@Q\x80``\x01`@R\x80`=\x81R` \x01aJq`=\x919`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x02\xF1\x91\x90a\x1A\xA5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x03\x08W__\xFD[PZ\xF1\x15\x80\x15a\x03\x1AW=__>=_\xFD[PPPP`%`$T`\"T`@Qa\x032\x90a\x18\xFBV[a\x03>\x93\x92\x91\x90a\x1D\xBEV[`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03WW=__>=_\xFD[PPV[``a\x03\x9E\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x11kV[\x94\x93PPPPV[``_a\x03\xB4\x85\x85\x85a\x03[V[\x90P_[a\x03\xC2\x85\x85a\x1E\xD7V[\x81\x10\x15a\x04\x0FW\x82\x82\x82\x81Q\x81\x10a\x03\xDCWa\x03\xDCa\x1E\xEAV[` \x02` \x01\x01Q`@Q` \x01a\x03\xF5\x92\x91\x90a\x1F.V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x03\xB8V[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04nW` \x02\x82\x01\x91\x90_R` _ \x90[\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04PW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05\xABW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x05\x94W\x83\x82\x90_R` _ \x01\x80Ta\x05\t\x90a\x1DmV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x055\x90a\x1DmV[\x80\x15a\x05\x80W\x80`\x1F\x10a\x05WWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05\x80V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05cW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x04\xECV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x04\x9BV[PPPP\x90P\x90V[a\x064`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16c\xE3\xD8\xD8\xD8`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06,\x91\x90a\x1FBV[`!Ta\x12\xCCV[a\x06\x88`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16c\x19\x10\xD9s`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\x08W=__>=_\xFD[a\x06\xDC`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16c\xC5\x82B\xCD`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\x08W=__>=_\xFD[`\x1FT`!T`@Q\x7F0\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\x81\x01\x91\x90\x91R_`$\x82\x01Ra\x07M\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90c0\x01{;\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\x08W=__>=_\xFD[`\x1FT`!T`@Q\x7F`\xB5\xC3\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\x81\x01\x91\x90\x91Ra\x07\xE4\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90c`\xB5\xC3\x90\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07\xB8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xDC\x91\x90a\x1FBV[`$Ta\x13PV[a\x08d`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16c\x117d\xBE`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x088W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\\\x91\x90a\x1FBV[`#Ta\x13PV[a\x08\xE2`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16c+\x97\xBE$`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\xB8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\xDC\x91\x90a\x1FBV[_a\x13PV[V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04nW` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04PWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04nW` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04PWPPPPP\x90P\x90V[``a\x03\x9E\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x13\xA8V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05\xABW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\n6\x90a\x1DmV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\nb\x90a\x1DmV[\x80\x15a\n\xADW\x80`\x1F\x10a\n\x84Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\xADV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\n\x90W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x0BDW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\n\xF1W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\n\x06V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05\xABW\x83\x82\x90_R` _ \x01\x80Ta\x0B\x9C\x90a\x1DmV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\xC8\x90a\x1DmV[\x80\x15a\x0C\x13W\x80`\x1F\x10a\x0B\xEAWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C\x13V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xF6W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0B\x7FV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05\xABW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\x05W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C\xB2W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0CJV[`@\x80Q\x80\x82\x01\x82R`\x11\x81R\x7FBad genesis block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\r\x9E\x91\x90`\x04\x01a\x1A\xA5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\r\xB5W__\xFD[PZ\xF1\x15\x80\x15a\r\xC7W=__>=_\xFD[PPPP`$T`\"T`@Qa\r\xDD\x90a\x18\xFBV[``\x80\x82R_\x90\x82\x01R` \x81\x01\x92\x90\x92R`@\x82\x01R`\x80\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x0E\x10W=__>=_\xFD[P`\x1F`\x01a\x01\0\n\x81T\x81`\x01`\x01`\xA0\x1B\x03\x02\x19\x16\x90\x83`\x01`\x01`\xA0\x1B\x03\x16\x02\x17\x90UPV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05\xABW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0F\x17W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0E\xC4W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0E\\V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05\xABW\x83\x82\x90_R` _ \x01\x80Ta\x0Fo\x90a\x1DmV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F\x9B\x90a\x1DmV[\x80\x15a\x0F\xE6W\x80`\x1F\x10a\x0F\xBDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F\xE6V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\xC9W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0FRV[`\x08T_\x90`\xFF\x16\x15a\x10\x11WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\xC3\x91\x90a\x1FBV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04nW` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04PWPPPPP\x90P\x90V[``a\x03\x9E\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x14\xF6V[``a\x11w\x84\x84a\x1E\xD7V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x11\x8FWa\x11\x8Fa\x19\x08V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x11\xC2W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x11\xADW\x90P[P\x90P\x83[\x83\x81\x10\x15a\x12\xC3Wa\x12\x95\x86a\x11\xDC\x83a\x16DV[\x85`@Q` \x01a\x11\xEF\x93\x92\x91\x90a\x1FYV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x12\x0B\x90a\x1DmV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x127\x90a\x1DmV[\x80\x15a\x12\x82W\x80`\x1F\x10a\x12YWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x12\x82V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x12eW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x17u\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x12\xA0\x87\x84a\x1E\xD7V[\x81Q\x81\x10a\x12\xB0Wa\x12\xB0a\x1E\xEAV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x11\xC7V[P\x94\x93PPPPV[`@Q\x7F|\x84\xC6\x9B\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c|\x84\xC6\x9B\x90`D\x01[_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x136W__\xFD[PZ\xFA\x15\x80\x15a\x13HW=__>=_\xFD[PPPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01a\x13 V[``a\x13\xB4\x84\x84a\x1E\xD7V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x13\xCCWa\x13\xCCa\x19\x08V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x13\xF5W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x12\xC3Wa\x14\xC8\x86a\x14\x0F\x83a\x16DV[\x85`@Q` \x01a\x14\"\x93\x92\x91\x90a\x1FYV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x14>\x90a\x1DmV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x14j\x90a\x1DmV[\x80\x15a\x14\xB5W\x80`\x1F\x10a\x14\x8CWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x14\xB5V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x14\x98W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x18\x14\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x14\xD3\x87\x84a\x1E\xD7V[\x81Q\x81\x10a\x14\xE3Wa\x14\xE3a\x1E\xEAV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x13\xFAV[``a\x15\x02\x84\x84a\x1E\xD7V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x15\x1AWa\x15\x1Aa\x19\x08V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x15CW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x12\xC3Wa\x16\x16\x86a\x15]\x83a\x16DV[\x85`@Q` \x01a\x15p\x93\x92\x91\x90a\x1FYV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x15\x8C\x90a\x1DmV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x15\xB8\x90a\x1DmV[\x80\x15a\x16\x03W\x80`\x1F\x10a\x15\xDAWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x16\x03V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15\xE6W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x18\xA7\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x16!\x87\x84a\x1E\xD7V[\x81Q\x81\x10a\x161Wa\x161a\x1E\xEAV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x15HV[``\x81_\x03a\x16\x86WPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x16\xAFW\x80a\x16\x99\x81a\x1F\xF6V[\x91Pa\x16\xA8\x90P`\n\x83a ZV[\x91Pa\x16\x89V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\xC9Wa\x16\xC9a\x19\x08V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x16\xF3W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x03\x9EWa\x17\x08`\x01\x83a\x1E\xD7V[\x91Pa\x17\x15`\n\x86a mV[a\x17 \x90`0a \x80V[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x175Wa\x175a\x1E\xEAV[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x17n`\n\x86a ZV[\x94Pa\x16\xF7V[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a\x17\xCA\x90\x86\x90\x86\x90`\x04\x01a \x93V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x17\xE4W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x18\x0B\x91\x90\x81\x01\x90a \xC0V[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x18h\x90\x86\x90\x86\x90`\x04\x01a \x93V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x18\x83W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x18\x0B\x91\x90a\x1FBV[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x18h\x90\x86\x90\x86\x90`\x04\x01a \x93V[a);\x80a!6\x839\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`A`\x04R`$_\xFD[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x19^Wa\x19^a\x19\x08V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x19\x7FWa\x19\x7Fa\x19\x08V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x19\x9FW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x19\xB5W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x19\xC5W__\xFD[\x805a\x19\xD8a\x19\xD3\x82a\x19fV[a\x195V[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x19\xECW__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1A\x99W`?\x19\x87\x86\x03\x01\x84Ra\x1A\x84\x85\x83Qa\x1A\x14V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1AhV[P\x92\x96\x95PPPPPPV[` \x81R_a\x18\x0B` \x83\x01\x84a\x1A\x14V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1A\xF7W\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1A\xD0V[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x1BPW`\x1F\x19\x85\x84\x03\x01\x88Ra\x1B:\x83\x83Qa\x1A\x14V[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x1B\x1EV[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1A\x99W`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1B\xBD`@\x87\x01\x82a\x1B\x02V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1B\x82V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1A\xF7W\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1B\xECV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x1C\\W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x1C\x1CV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1A\x99W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x1C\xB2`@\x88\x01\x82a\x1A\x14V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x1C\xCD\x81\x83a\x1C\nV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1C\x8CV[` \x81R_a\x18\x0B` \x83\x01\x84a\x1B\x02V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1A\x99W`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1DW`@\x87\x01\x82a\x1C\nV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1D\x1CV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1D\x81W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x1D\xB8W\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[P\x91\x90PV[``\x81R__\x85T_\x81`\x01\x1C\x90P`\x01\x82\x16\x80a\x1D\xDDW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x1E\x14W\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[``\x86\x01\x82\x90R`\x80\x86\x01\x81\x80\x15a\x1E3W`\x01\x81\x14a\x1EgWa\x1E\x93V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x85\x16\x82R\x83\x15\x15`\x05\x1B\x82\x01\x95Pa\x1E\x93V[_\x8B\x81R` \x90 _[\x85\x81\x10\x15a\x1E\x8DW\x81T\x84\x82\x01R`\x01\x90\x91\x01\x90` \x01a\x1EqV[\x83\x01\x96PP[PPPPP` \x83\x01\x94\x90\x94RP`@\x01R\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[\x81\x81\x03\x81\x81\x11\x15a\x18\x0EWa\x18\x0Ea\x1E\xAAV[\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x03\x9Ea\x1F<\x83\x86a\x1F\x17V[\x84a\x1F\x17V[_` \x82\x84\x03\x12\x15a\x1FRW__\xFD[PQ\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\x81R_a\x1F\x8A`\x01\x83\x01\x86a\x1F\x17V[\x7F[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x1F\xBA`\x01\x82\x01\x86a\x1F\x17V[\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\x81Ra\x1F\xEC`\x02\x82\x01\x85a\x1F\x17V[\x96\x95PPPPPPV[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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 &Wa &a\x1E\xAAV[P`\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`\x12`\x04R`$_\xFD[_\x82a hWa ha -V[P\x04\x90V[_\x82a {Wa {a -V[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a\x18\x0EWa\x18\x0Ea\x1E\xAAV[`@\x81R_a \xA5`@\x83\x01\x85a\x1A\x14V[\x82\x81\x03` \x84\x01Ra \xB7\x81\x85a\x1A\x14V[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a \xD0W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a \xE6W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a \xF6W__\xFD[\x80Qa!\x04a\x19\xD3\x82a\x19fV[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a!\x18W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa);8\x03\x80a);\x839\x81\x01`@\x81\x90Ra\0.\x91a\x03+V[\x82\x82\x82\x82\x82\x82a\0?\x83Q`P\x14\x90V[a\0\x84W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x11`$\x82\x01RpBad genesis block`x\x1B`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\0\x8E\x84a\x01fV[\x90Pb\xFF\xFF\xFF\x82\x16\x15a\x01\tW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FPeriod start hash does not have `D\x82\x01R\x7Fwork. Hint: wrong byte order?\0\0\0`d\x82\x01R`\x84\x01a\0{V[_\x81\x81U`\x01\x82\x90U`\x02\x82\x90U\x81\x81R`\x04` R`@\x90 \x83\x90Ua\x012a\x07\xE0\x84a\x03\xFEV[a\x01<\x90\x84a\x04%V[_\x83\x81R`\x04` R`@\x90 Ua\x01S\x84a\x02&V[`\x05UPa\x05\xBD\x98PPPPPPPPPV[_`\x02\x80\x83`@Qa\x01x\x91\x90a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\x93W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x04NV[`@Q` \x01a\x01\xC8\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x01\xE2\x91a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\xFDW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02 \x91\x90a\x04NV[\x92\x91PPV[_a\x02 a\x023\x83a\x028V[a\x02CV[_a\x02 \x82\x82a\x02SV[_a\x02 a\xFF\xFF`\xD0\x1B\x83a\x02\xF7V[_\x80a\x02ja\x02c\x84`Ha\x04eV[\x85\x90a\x03\tV[`\xE8\x1C\x90P_\x84a\x02|\x85`Ka\x04eV[\x81Q\x81\x10a\x02\x8CWa\x02\x8Ca\x04xV[\x01` \x01Q`\xF8\x1C\x90P_a\x02\xBE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x02\xD1`\x03\x84a\x04\x8CV[`\xFF\x16\x90Pa\x02\xE2\x81a\x01\0a\x05\x88V[a\x02\xEC\x90\x83a\x05\x93V[\x97\x96PPPPPPPV[_a\x03\x02\x82\x84a\x05\xAAV[\x93\x92PPPV[_a\x03\x02\x83\x83\x01` \x01Q\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x03=W__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03RW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03bW__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03{Wa\x03{a\x03\x17V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x03\xA9Wa\x03\xA9a\x03\x17V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x03\xC0W__\xFD[\x81` \x84\x01` \x83\x01^_` \x92\x82\x01\x83\x01R\x90\x86\x01Q`@\x90\x96\x01Q\x90\x97\x95\x96P\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x04\x0CWa\x04\x0Ca\x03\xEAV[P\x06\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x04^W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02 Wa\x02 a\x04\x11V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[`\x01\x81[`\x01\x84\x11\x15a\x04\xE0W\x80\x85\x04\x81\x11\x15a\x04\xC4Wa\x04\xC4a\x04\x11V[`\x01\x84\x16\x15a\x04\xD2W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x04\xA9V[\x93P\x93\x91PPV[_\x82a\x04\xF6WP`\x01a\x02 V[\x81a\x05\x02WP_a\x02 V[\x81`\x01\x81\x14a\x05\x18W`\x02\x81\x14a\x05\"Wa\x05>V[`\x01\x91PPa\x02 V[`\xFF\x84\x11\x15a\x053Wa\x053a\x04\x11V[PP`\x01\x82\x1Ba\x02 V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x05aWP\x81\x81\na\x02 V[a\x05m_\x19\x84\x84a\x04\xA5V[\x80_\x19\x04\x82\x11\x15a\x05\x80Wa\x05\x80a\x04\x11V[\x02\x93\x92PPPV[_a\x03\x02\x83\x83a\x04\xE8V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x02 Wa\x02 a\x04\x11V[_\x82a\x05\xB8Wa\x05\xB8a\x03\xEAV[P\x04\x90V[a#q\x80a\x05\xCA_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\xADW\x80c\xB9\x85b\x1A\x11a\0}W\x80c\xE3\xD8\xD8\xD8\x11a\0cW\x80c\xE3\xD8\xD8\xD8\x14a\x02\"W\x80c\xE4q\xE7,\x14a\x02)W\x80c\xF5\x8D\xB0o\x14a\x02=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x13\x91\x90a!WV[`@Q` \x01a\x0C%\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\x90\x82\x90Ra\x0C]\x91a!AV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0CxW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x07\x91\x90a!WV[_\x83\x85\x14\x80\x15a\x0C\xAAWP\x82\x85\x14[\x15a\x0C\xB7WP`\x01a\x04\xF1V[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x0C\xFFW\x89\x83\x14a\x0C\xDEW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x0C\xF7W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x0C\xBDV[P\x82\x84\x03a\r\x13W_\x94PPPPPa\x04\xF1V[\x80\x82\x14a\r&W_\x94PPPPPa\x04\xF1V[P`\x01\x98\x97PPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\rYW_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\r9V[P\x80a\x05\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x80\x82\x81[a\r\xB8`\x04`\x01a!\x9BV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0E\x0CW_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\r\xF1W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0E\x04V[a\r\xFB\x81\x84a!\xB7V[\x95\x94PPPPPV[`\x01\x01a\r\xACV[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_`P\x82Qa\x0B~\x91\x90a!.V[__a\x0Eo\x85a\x0B\xC3V[\x90P_a\x0E{\x82a\r\xA7V[\x90P_a\x0E\x87\x86a\x19\xE6V[\x90P\x84\x80a\x0E\x9CWP\x80a\x0E\x9A\x88a\x19\xE6V[\x14[a\x0F\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x03.V[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x12\x0EWa\x0F(`P\x82a!\xCAV[a\x0F3\x90`\x01a!\xB7V[a\x0F=\x90\x87a!\xB7V[\x93Pa\x0FK\x8A\x82`Pa\x19\xF1V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x11!W\x84a\x10\xA1\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x10\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x11\n`\x04\x85a!.V[_\x03a\x11!W_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x11,\x8B\x83a\x1A\x16V[\x14a\x11yW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[\x86a\x11\x84\x8B\x83a\x1A\xAFV[\x14a\x11\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x03.V[\x82\x96P`P\x81a\x12\x07\x91\x90a!\xB7V[\x90Pa\x0F\x15V[P\x81a\x12\x19\x8Ba\x0B\xC3V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x12\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x12\xD4\x84a\x0B\xC3V[\x90P_a\x12\xE0\x86a\x0B\xC3V[\x90P`\x01T\x81\x14a\x133W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x03.V[_\x82\x81R`\x03` R`@\x90 Ta\x13\x8DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x13\x9B\x87`\x01T\x84\x87a\x0C\x9BV[a\x14\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x03.V[\x81a\x14\x19\x88\x88\x88a\x17\x80V[\x14a\x14\x8CW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[`\x01\x82\x90U`\x02\x87\x90U_a\x14\xA0\x86a\x1A\xC7V[\x90P`\x05T\x81\x14a\x14\xB1W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x15\x01a\x14\xFC\x86a\x0B\xC3V[a\r\xA7V[\x90P_a\x15\x10a\x14\xFC\x86a\x0B\xC3V[\x90Pa\x15\x1Ea\x07\xE0\x82a!.V[a\x07\xDF\x14a\x15\x94W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x03.V[a\x15\xA0\x82a\x07\xDFa!\xB7V[\x81\x14a\x16\x14W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x03.V[a\x16\x1D\x85a\x1A\xC7V[a\x16&\x87a\x1A\xC7V[\x14a\x16\x99W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x03.V[_a\x16\xA3\x85a\x19\xE6V[\x90P_a\x16\xD5a\x16\xB2\x89a\x19\xE6V[a\x16\xBB\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x16\xCA\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x1B\x0CV[\x90P\x81\x81\x83\x16\x14a\x17(W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_a\x172\x89a\x1A\xC7V[\x90P\x80`\x06T\x14\x15\x80\x15a\x17\\WPa\x07\xE0a\x17O`\x01Ta\r\xA7V[a\x17Y\x91\x90a!\xDDV[\x84\x11[\x15a\x17gW`\x06\x81\x90U[a\x17s\x88\x88`\x01a\x0EdV[\x99\x98PPPPPPPPPV[__a\x17\x8B\x85a\r\xA7V[\x90P_a\x17\x9Aa\x14\xFC\x86a\x0B\xC3V[\x90P_a\x17\xA9a\x14\xFC\x86a\x0B\xC3V[\x90P\x82\x82\x10\x15\x80\x15a\x17\xBBWP\x82\x81\x10\x15[a\x18-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x18:a\x07\xE0\x85a!.V[a\x18F\x85a\x07\xE0a!\xB7V[a\x18P\x91\x90a!\xDDV[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x18bWP\x80[\x15a\x18}Wa\x18p\x89a\x0B\xC3V[\x96PPPPPPPa\n\xA3V[\x81\x80\x15a\x18\x88WP\x80\x15[\x15a\x18\x96Wa\x18p\x88a\x0B\xC3V[\x81\x80\x15a\x18\xA0WP\x80[\x15a\x18\xC4W\x83\x85\x10\x15a\x18\xBBWa\x18\xB6\x88a\x0B\xC3V[a\x18pV[a\x18p\x89a\x0B\xC3V[a\x18\xCD\x88a\x1A\xC7V[a\x18\xD9a\x07\xE0\x86a!.V[a\x18\xE3\x91\x90a!\xF0V[a\x18\xEC\x8Aa\x1A\xC7V[a\x18\xF8a\x07\xE0\x88a!.V[a\x19\x02\x91\x90a!\xF0V[\x10\x15a\x18\xBBWa\x18p\x88a\x0B\xC3V[`\x07T_\x90`\xFF\x16\x15a\x19/WP`\x07Ta\x01\0\x90\x04`\xFF\x16a\n\xA3V[a\x19:\x84\x84\x84a\x1B\x94V[\x90Pa\n\xA3V[_` \x84Qa\x19P\x91\x90a!.V[\x15a\x19\\WP_a\x04\xF1V[\x83Q_\x03a\x19kWP_a\x04\xF1V[\x81\x85_[\x86Q\x81\x10\x15a\x19\xD9Wa\x19\x83`\x02\x84a!.V[`\x01\x03a\x19\xA7Wa\x19\xA0a\x19\x9A\x88\x83\x01` \x01Q\x90V[\x83a\x1B\xD5V[\x91Pa\x19\xC0V[a\x19\xBD\x82a\x19\xB8\x89\x84\x01` \x01Q\x90V[a\x1B\xD5V[\x91P[`\x01\x92\x90\x92\x1C\x91a\x19\xD2` \x82a!\xB7V[\x90Pa\x19oV[P\x90\x93\x14\x95\x94PPPPPV[_a\x05\x07\x82_a\x1A\x16V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x1A-a\x1A&\x84`Ha!\xB7V[\x85\x90a\x1B\xE0V[`\xE8\x1C\x90P_\x84a\x1A?\x85`Ka!\xB7V[\x81Q\x81\x10a\x1AOWa\x1AOa\"\x07V[\x01` \x01Q`\xF8\x1C\x90P_a\x1A\x81\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1A\x94`\x03\x84a\"4V[`\xFF\x16\x90Pa\x1A\xA5\x81a\x01\0a#0V[a\x08-\x90\x83a!\xF0V[_a\x05\x04a\x1A\xBE\x83`\x04a!\xB7V[\x84\x01` \x01Q\x90V[_a\x05\x07a\x1A\xD4\x83a\x19\xE6V[a\x1B\xEEV[_a\x05\x07a\x1A\xE6\x83a\x1C\x15V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1B\x18\x83\x85a\x1C!V[\x90Pa\x1B(b\x12u\0`\x04a\x1C|V[\x81\x10\x15a\x1B@Wa\x1B=b\x12u\0`\x04a\x1C|V[\x90P[a\x1BNb\x12u\0`\x04a\x1C\x87V[\x81\x11\x15a\x1BfWa\x1Bcb\x12u\0`\x04a\x1C\x87V[\x90P[_a\x1B~\x82a\x1Bx\x88b\x01\0\0a\x1C|V[\x90a\x1C\x87V[\x90Pa\n\x8Ab\x01\0\0a\x1Bx\x83b\x12u\0a\x1C|V[_\x82\x81[\x83\x81\x10\x15a\x1B\xCAW\x85\x82\x03a\x1B\xB2W`\x01\x92PPPa\n\xA3V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x1B\x98V[P_\x95\x94PPPPPV[_a\x05\x04\x83\x83a\x1C\xFAV[_a\x05\x04\x83\x83\x01` \x01Q\x90V[_a\x05\x07{\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\x83a\x1C|V[_a\x05\x07\x82`Da\x1B\xE0V[_\x82\x82\x11\x15a\x1CrW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x05\x04\x82\x84a!\xDDV[_a\x05\x04\x82\x84a!\xCAV[_\x82_\x03a\x1C\x96WP_a\x05\x07V[a\x1C\xA0\x82\x84a!\xF0V[\x90P\x81a\x1C\xAD\x84\x83a!\xCAV[\x14a\x05\x07W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x03.V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1D1W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DHW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1D_W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1DvW__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1D\x91W__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xA7W__\xFD[a\x1D\xB3\x8A\x82\x8B\x01a\x1D!V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xD2W__\xFD[a\x1D\xDE\x8A\x82\x8B\x01a\x1D!V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1D\xFE`\x80\x89\x01a\x1DfV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[____`\x80\x85\x87\x03\x12\x15a\x1E\x1FW__\xFD[PP\x825\x94` \x84\x015\x94P`@\x84\x015\x93``\x015\x92P\x90PV[__`@\x83\x85\x03\x12\x15a\x1ELW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1EkW__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1E\x85W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x9BW__\xFD[a\x1E\xA7\x87\x82\x88\x01a\x1D!V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\xC6W__\xFD[a\x1E\xD2\x87\x82\x88\x01a\x1D!V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1E\xF3W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x10W__\xFD[a\x1F\x1C\x89\x82\x8A\x01a\x1D!V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F;W__\xFD[a\x1FG\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1FtW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x8AW__\xFD[a\x1F\x96\x89\x82\x8A\x01a\x1D!V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xB5W__\xFD[a\x1F\xC1\x89\x82\x8A\x01a\x1D!V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xE0W__\xFD[a\x1F\xEC\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_____``\x86\x88\x03\x12\x15a \x12W__\xFD[\x855\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a /W__\xFD[a ;\x88\x82\x89\x01a\x1D!V[\x90\x95P\x93PP`@\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a ZW__\xFD[a f\x88\x82\x89\x01a\x1D!V[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[___``\x84\x86\x03\x12\x15a \x89W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a \xB1W__\xFD[\x825\x91Pa \xC1` \x84\x01a\x1DfV[\x90P\x92P\x92\x90PV[\x805\x80\x15\x15\x81\x14a\x1DvW__\xFD[__`@\x83\x85\x03\x12\x15a \xEAW__\xFD[a \xF3\x83a \xCAV[\x91Pa \xC1` \x84\x01a \xCAV[\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! = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolConstructor for constructorCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getBlockHeights(string,uint256,uint256)` and selector `0xfad06b8f`. -```solidity -function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getBlockHeightsCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getBlockHeights(string,uint256,uint256)`](getBlockHeightsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getBlockHeightsReturn { - #[allow(missing_docs)] - pub elements: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getBlockHeightsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - #[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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getBlockHeightsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getBlockHeightsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getBlockHeights(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [250u8, 208u8, 107u8, 143u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getDigestLes(string,uint256,uint256)` and selector `0x44badbb6`. -```solidity -function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getDigestLesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getDigestLes(string,uint256,uint256)`](getDigestLesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getDigestLesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getDigestLesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getDigestLesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getDigestLesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array< - alloy::sol_types::sol_data::FixedBytes<32>, - >, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getDigestLes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [68u8, 186u8, 219u8, 182u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaderHexes(string,uint256,uint256)` and selector `0x0813852a`. -```solidity -function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaderHexes(string,uint256,uint256)`](getHeaderHexesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeaderHexesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getHeaderHexesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getHeaderHexesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Bytes, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaderHexes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [8u8, 19u8, 133u8, 42u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaders(string,uint256,uint256)` and selector `0x1c0da81f`. -```solidity -function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaders(string,uint256,uint256)`](getHeadersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersReturn { - #[allow(missing_docs)] - pub headers: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersReturn) -> Self { - (value.headers,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { headers: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getHeadersCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Bytes; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaders(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [28u8, 13u8, 168u8, 31u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testBadGenesisBlock()` and selector `0x991460cd`. -```solidity -function testBadGenesisBlock() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testBadGenesisBlockCall; - ///Container type for the return parameters of the [`testBadGenesisBlock()`](testBadGenesisBlockCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testBadGenesisBlockReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testBadGenesisBlockCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testBadGenesisBlockCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testBadGenesisBlockReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testBadGenesisBlockReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testBadGenesisBlockReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testBadGenesisBlockCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testBadGenesisBlockReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testBadGenesisBlock()"; - const SELECTOR: [u8; 4] = [153u8, 20u8, 96u8, 205u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testBadGenesisBlockReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testPeriodStartWrongByteOrder()` and selector `0x06d57e33`. -```solidity -function testPeriodStartWrongByteOrder() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testPeriodStartWrongByteOrderCall; - ///Container type for the return parameters of the [`testPeriodStartWrongByteOrder()`](testPeriodStartWrongByteOrderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testPeriodStartWrongByteOrderReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testPeriodStartWrongByteOrderCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testPeriodStartWrongByteOrderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testPeriodStartWrongByteOrderReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testPeriodStartWrongByteOrderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testPeriodStartWrongByteOrderReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testPeriodStartWrongByteOrderCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testPeriodStartWrongByteOrderReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testPeriodStartWrongByteOrder()"; - const SELECTOR: [u8; 4] = [6u8, 213u8, 126u8, 51u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testPeriodStartWrongByteOrderReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testStoresGenesisBlockInfo()` and selector `0x2c503d91`. -```solidity -function testStoresGenesisBlockInfo() external view; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testStoresGenesisBlockInfoCall; - ///Container type for the return parameters of the [`testStoresGenesisBlockInfo()`](testStoresGenesisBlockInfoCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testStoresGenesisBlockInfoReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testStoresGenesisBlockInfoCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testStoresGenesisBlockInfoCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testStoresGenesisBlockInfoReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testStoresGenesisBlockInfoReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testStoresGenesisBlockInfoReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testStoresGenesisBlockInfoCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testStoresGenesisBlockInfoReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testStoresGenesisBlockInfo()"; - const SELECTOR: [u8; 4] = [44u8, 80u8, 61u8, 145u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testStoresGenesisBlockInfoReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`FullRelayConstructionTest`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum FullRelayConstructionTestCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - getBlockHeights(getBlockHeightsCall), - #[allow(missing_docs)] - getDigestLes(getDigestLesCall), - #[allow(missing_docs)] - getHeaderHexes(getHeaderHexesCall), - #[allow(missing_docs)] - getHeaders(getHeadersCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - testBadGenesisBlock(testBadGenesisBlockCall), - #[allow(missing_docs)] - testPeriodStartWrongByteOrder(testPeriodStartWrongByteOrderCall), - #[allow(missing_docs)] - testStoresGenesisBlockInfo(testStoresGenesisBlockInfoCall), - } - #[automatically_derived] - impl FullRelayConstructionTestCalls { - /// 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, 213u8, 126u8, 51u8], - [8u8, 19u8, 133u8, 42u8], - [28u8, 13u8, 168u8, 31u8], - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [44u8, 80u8, 61u8, 145u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [68u8, 186u8, 219u8, 182u8], - [102u8, 217u8, 169u8, 160u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [153u8, 20u8, 96u8, 205u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [226u8, 12u8, 159u8, 113u8], - [250u8, 118u8, 38u8, 212u8], - [250u8, 208u8, 107u8, 143u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for FullRelayConstructionTestCalls { - const NAME: &'static str = "FullRelayConstructionTestCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 19usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::getBlockHeights(_) => { - ::SELECTOR - } - Self::getDigestLes(_) => { - ::SELECTOR - } - Self::getHeaderHexes(_) => { - ::SELECTOR - } - Self::getHeaders(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::testBadGenesisBlock(_) => { - ::SELECTOR - } - Self::testPeriodStartWrongByteOrder(_) => { - ::SELECTOR - } - Self::testStoresGenesisBlockInfo(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn testPeriodStartWrongByteOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - FullRelayConstructionTestCalls::testPeriodStartWrongByteOrder, - ) - } - testPeriodStartWrongByteOrder - }, - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayConstructionTestCalls::getHeaderHexes) - } - getHeaderHexes - }, - { - fn getHeaders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayConstructionTestCalls::getHeaders) - } - getHeaders - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayConstructionTestCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayConstructionTestCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn testStoresGenesisBlockInfo( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - FullRelayConstructionTestCalls::testStoresGenesisBlockInfo, - ) - } - testStoresGenesisBlockInfo - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayConstructionTestCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayConstructionTestCalls::targetContracts) - } - targetContracts - }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayConstructionTestCalls::getDigestLes) - } - getDigestLes - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayConstructionTestCalls::targetArtifactSelectors) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayConstructionTestCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayConstructionTestCalls::targetSelectors) - } - targetSelectors - }, - { - fn testBadGenesisBlock( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayConstructionTestCalls::testBadGenesisBlock) - } - testBadGenesisBlock - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayConstructionTestCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayConstructionTestCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(FullRelayConstructionTestCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayConstructionTestCalls::excludeContracts) - } - excludeContracts - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(FullRelayConstructionTestCalls::IS_TEST) - } - IS_TEST - }, - { - fn getBlockHeights( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayConstructionTestCalls::getBlockHeights) - } - getBlockHeights - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn testPeriodStartWrongByteOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayConstructionTestCalls::testPeriodStartWrongByteOrder, - ) - } - testPeriodStartWrongByteOrder - }, - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayConstructionTestCalls::getHeaderHexes) - } - getHeaderHexes - }, - { - fn getHeaders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayConstructionTestCalls::getHeaders) - } - getHeaders - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayConstructionTestCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayConstructionTestCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn testStoresGenesisBlockInfo( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayConstructionTestCalls::testStoresGenesisBlockInfo, - ) - } - testStoresGenesisBlockInfo - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayConstructionTestCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayConstructionTestCalls::targetContracts) - } - targetContracts - }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayConstructionTestCalls::getDigestLes) - } - getDigestLes - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayConstructionTestCalls::targetArtifactSelectors) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayConstructionTestCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayConstructionTestCalls::targetSelectors) - } - targetSelectors - }, - { - fn testBadGenesisBlock( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayConstructionTestCalls::testBadGenesisBlock) - } - testBadGenesisBlock - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayConstructionTestCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayConstructionTestCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayConstructionTestCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayConstructionTestCalls::excludeContracts) - } - excludeContracts - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayConstructionTestCalls::IS_TEST) - } - IS_TEST - }, - { - fn getBlockHeights( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayConstructionTestCalls::getBlockHeights) - } - getBlockHeights - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::getBlockHeights(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getDigestLes(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getHeaders(inner) => { - ::abi_encoded_size(inner) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testBadGenesisBlock(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testPeriodStartWrongByteOrder(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testStoresGenesisBlockInfo(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::getBlockHeights(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getDigestLes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testBadGenesisBlock(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testPeriodStartWrongByteOrder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testStoresGenesisBlockInfo(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`FullRelayConstructionTest`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum FullRelayConstructionTestEvents { - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl FullRelayConstructionTestEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for FullRelayConstructionTestEvents { - const NAME: &'static str = "FullRelayConstructionTestEvents"; - const COUNT: usize = 22usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 FullRelayConstructionTestEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`FullRelayConstructionTest`](self) contract instance. - -See the [wrapper's documentation](`FullRelayConstructionTestInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> FullRelayConstructionTestInstance { - FullRelayConstructionTestInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - FullRelayConstructionTestInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - FullRelayConstructionTestInstance::::deploy_builder(provider) - } - /**A [`FullRelayConstructionTest`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`FullRelayConstructionTest`](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 FullRelayConstructionTestInstance< - P, - N = alloy_contract::private::Ethereum, - > { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for FullRelayConstructionTestInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("FullRelayConstructionTestInstance") - .field(&self.address) - .finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayConstructionTestInstance { - /**Creates a new wrapper around an on-chain [`FullRelayConstructionTest`](self) contract instance. - -See the [wrapper's documentation](`FullRelayConstructionTestInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 FullRelayConstructionTestInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> FullRelayConstructionTestInstance { - FullRelayConstructionTestInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayConstructionTestInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`getBlockHeights`] function. - pub fn getBlockHeights( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getBlockHeightsCall, N> { - self.call_builder( - &getBlockHeightsCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getDigestLes`] function. - pub fn getDigestLes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getDigestLesCall, N> { - self.call_builder( - &getDigestLesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaderHexes`] function. - pub fn getHeaderHexes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeaderHexesCall, N> { - self.call_builder( - &getHeaderHexesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaders`] function. - pub fn getHeaders( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeadersCall, N> { - self.call_builder( - &getHeadersCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`testBadGenesisBlock`] function. - pub fn testBadGenesisBlock( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testBadGenesisBlockCall, N> { - self.call_builder(&testBadGenesisBlockCall) - } - ///Creates a new call builder for the [`testPeriodStartWrongByteOrder`] function. - pub fn testPeriodStartWrongByteOrder( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testPeriodStartWrongByteOrderCall, N> { - self.call_builder(&testPeriodStartWrongByteOrderCall) - } - ///Creates a new call builder for the [`testStoresGenesisBlockInfo`] function. - pub fn testStoresGenesisBlockInfo( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testStoresGenesisBlockInfoCall, N> { - self.call_builder(&testStoresGenesisBlockInfoCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayConstructionTestInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/fullrelayheaviestfromancestorwithretargettest.rs b/crates/bindings/src/fullrelayheaviestfromancestorwithretargettest.rs deleted file mode 100644 index 12498ede3..000000000 --- a/crates/bindings/src/fullrelayheaviestfromancestorwithretargettest.rs +++ /dev/null @@ -1,8902 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface FullRelayHeaviestFromAncestorWithRetargetTest { - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - constructor(); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); - function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); - function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); - function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function testHandlingDescendantsAtDifferentDifficultyPeriod() external view; - function testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriod() external view; -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getBlockHeights", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getDigestLes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes32[]", - "internalType": "bytes32[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaderHexes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes[]", - "internalType": "bytes[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaders", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "headers", - "type": "bytes", - "internalType": "bytes" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testHandlingDescendantsAtDifferentDifficultyPeriod", - "inputs": [], - "outputs": [], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriod", - "inputs": [], - "outputs": [], - "stateMutability": "view" - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 FullRelayHeaviestFromAncestorWithRetargetTest { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x6080604052600c8054600160ff199182168117909255601f8054909116909117905534801561002c575f5ffd5b506040518060400160405280601c81526020017f6865616465727352656f7267416e6452657461726765742e6a736f6e000000008152506040518060400160405280600c81526020016b05ccecadccae6d2e65cd0caf60a31b8152506040518060400160405280600f81526020016e0b99d95b995cda5ccb9a195a59da1d608a1b8152506040518060400160405280601981526020017f2e6f6c64506572696f6453746172742e6469676573745f6c65000000000000008152505f5f516020615a6f5f395f51905f526001600160a01b031663d930a0e66040518163ffffffff1660e01b81526004015f60405180830381865afa15801561012f573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d908101601f191682016040526101569190810190610dd5565b90505f818660405160200161016c929190610e30565b60408051601f19818403018152908290526360f9bb1160e01b825291505f516020615a6f5f395f51905f52906360f9bb11906101ac908490600401610ea2565b5f60405180830381865afa1580156101c6573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d908101601f191682016040526101ed9190810190610dd5565b6020906101fa9082610f38565b50610291856020805461020c90610eb4565b80601f016020809104026020016040519081016040528092919081815260200182805461023890610eb4565b80156102835780601f1061025a57610100808354040283529160200191610283565b820191905f5260205f20905b81548152906001019060200180831161026657829003601f168201915b5093949350506108e0915050565b61032785602080546102a290610eb4565b80601f01602080910402602001604051908101604052809291908181526020018280546102ce90610eb4565b80156103195780601f106102f057610100808354040283529160200191610319565b820191905f5260205f20905b8154815290600101906020018083116102fc57829003601f168201915b50939493505061095f915050565b6103bd856020805461033890610eb4565b80601f016020809104026020016040519081016040528092919081815260200182805461036490610eb4565b80156103af5780601f10610386576101008083540402835291602001916103af565b820191905f5260205f20905b81548152906001019060200180831161039257829003601f168201915b5093949350506109d2915050565b6040516103c990610c81565b6103d593929190610ff2565b604051809103905ff0801580156103ee573d5f5f3e3d5ffd5b50601f60016101000a8154816001600160a01b0302191690836001600160a01b031602179055505050505050506104556040518060400160405280601081526020016f383932a932ba30b933b2ba21b430b4b760811b8152505f6005610a0660201b60201c565b805161046991602191602090910190610c8e565b5060408051808201909152601181525f516020615a4f5f395f51905f526020820152610497905f6008610a06565b80516104ab91602291602090910190610c8e565b5060408051808201909152601181525f516020615a4f5f395f51905f5260208201526104e3905f6104de6002600861102a565b610a06565b80516104f791602391602090910190610c8e565b505f6105336040518060400160405280601081526020016f383932a932ba30b933b2ba21b430b4b760811b8152505f6005610a3d60201b60201c565b90505f61056a6040518060400160405280601181526020015f516020615a4f5f395f51905f528152505f6008610a3d60201b60201c565b90505f6105a76040518060400160405280601181526020015f516020615a4f5f395f51905f528152505f600260086105a2919061102a565b610a3d565b90506105e46040518060400160405280601281526020017105cdee4e0d0c2dcbe68666e686e705cd0caf60731b8152506020805461020c90610eb4565b6025906105f19082610f38565b506106386040518060400160405280601881526020017f2e6f727068616e5f3433373437382e6469676573745f6c6500000000000000008152506020805461033890610eb4565b6026556040515f9061065190839060259060200161103d565b60405160208183030381529060405290505f6106986040518060400160405280600c81526020016b05ccecadccae6d2e65cd0caf60a31b8152506020805461020c90610eb4565b90506106d5604051806040016040528060128152602001712e67656e657369732e6469676573745f6c6560701b8152506020805461033890610eb4565b6024819055505f6107226040518060400160405280601381526020017f2e6f6c64506572696f6453746172742e686578000000000000000000000000008152506020805461020c90610eb4565b601f546040516365da41b960e01b815291925061010090046001600160a01b0316906365da41b99061075a9085908a906004016110ba565b6020604051808303815f875af1158015610776573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061079a91906110de565b50601f5461010090046001600160a01b0316637fa637fc8260216107c06001600561102a565b815481106107d0576107d0611104565b905f5260205f2001886040518463ffffffff1660e01b81526004016107f793929190611118565b6020604051808303815f875af1158015610813573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061083791906110de565b50601f5461010090046001600160a01b0316637fa637fc82602161085d6001600561102a565b8154811061086d5761086d611104565b905f5260205f2001866040518463ffffffff1660e01b815260040161089493929190611118565b6020604051808303815f875af11580156108b0573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906108d491906110de565b505050505050506112a2565b604051631fb2437d60e31b81526060905f516020615a6f5f395f51905f529063fd921be89061091590869086906004016110ba565b5f60405180830381865afa15801561092f573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d908101601f191682016040526109569190810190610dd5565b90505b92915050565b6040516356eef15b60e11b81525f905f516020615a6f5f395f51905f529063addde2b69061099390869086906004016110ba565b602060405180830381865afa1580156109ae573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061095691906111c8565b604051631777e59d60e01b81525f905f516020615a6f5f395f51905f5290631777e59d9061099390869086906004016110ba565b6060610a35848484604051806040016040528060038152602001620d0caf60eb1b815250610aaf60201b60201c565b949350505050565b60605f610a4b858585610a06565b90505f5b610a59858561102a565b811015610aa65782828281518110610a7357610a73611104565b6020026020010151604051602001610a8c9291906111df565b60408051601f198184030181529190529250600101610a4f565b50509392505050565b6060610abb848461102a565b6001600160401b03811115610ad257610ad2610d4c565b604051908082528060200260200182016040528015610b0557816020015b6060815260200190600190039081610af05790505b509050835b83811015610b7c57610b4e86610b1f83610b85565b85604051602001610b32939291906111f3565b6040516020818303038152906040526020805461020c90610eb4565b82610b59878461102a565b81518110610b6957610b69611104565b6020908102919091010152600101610b0a565b50949350505050565b6060815f03610bab5750506040805180820190915260018152600360fc1b602082015290565b815f5b8115610bd45780610bbe8161123d565b9150610bcd9050600a83611269565b9150610bae565b5f816001600160401b03811115610bed57610bed610d4c565b6040519080825280601f01601f191660200182016040528015610c17576020820181803683370190505b5090505b8415610a3557610c2c60018361102a565b9150610c39600a8661127c565b610c4490603061128f565b60f81b818381518110610c5957610c59611104565b60200101906001600160f81b03191690815f1a905350610c7a600a86611269565b9450610c1b565b61293b8061311483390190565b828054828255905f5260205f20908101928215610cd2579160200282015b82811115610cd25782518290610cc29082610f38565b5091602001919060010190610cac565b50610cde929150610ce2565b5090565b80821115610cde575f610cf58282610cfe565b50600101610ce2565b508054610d0a90610eb4565b5f825580601f10610d19575050565b601f0160209004905f5260205f2090810190610d359190610d38565b50565b5b80821115610cde575f8155600101610d39565b634e487b7160e01b5f52604160045260245ffd5b5f806001600160401b03841115610d7957610d79610d4c565b50604051601f19601f85018116603f011681018181106001600160401b0382111715610da757610da7610d4c565b604052838152905080828401851015610dbe575f5ffd5b8383602083015e5f60208583010152509392505050565b5f60208284031215610de5575f5ffd5b81516001600160401b03811115610dfa575f5ffd5b8201601f81018413610e0a575f5ffd5b610a3584825160208401610d60565b5f81518060208401855e5f93019283525090919050565b5f610e3b8285610e19565b7f2f746573742f66756c6c52656c61792f74657374446174612f000000000000008152610e6b6019820185610e19565b95945050505050565b5f81518084528060208401602086015e5f602082860101526020601f19601f83011685010191505092915050565b602081525f6109566020830184610e74565b600181811c90821680610ec857607f821691505b602082108103610ee657634e487b7160e01b5f52602260045260245ffd5b50919050565b601f821115610f3357805f5260205f20601f840160051c81016020851015610f115750805b601f840160051c820191505b81811015610f30575f8155600101610f1d565b50505b505050565b81516001600160401b03811115610f5157610f51610d4c565b610f6581610f5f8454610eb4565b84610eec565b6020601f821160018114610f97575f8315610f805750848201515b5f19600385901b1c1916600184901b178455610f30565b5f84815260208120601f198516915b82811015610fc65787850151825560209485019460019092019101610fa6565b5084821015610fe357868401515f19600387901b60f8161c191681555b50505050600190811b01905550565b606081525f6110046060830186610e74565b60208301949094525060400152919050565b634e487b7160e01b5f52601160045260245ffd5b8181038181111561095957610959611016565b5f6110488285610e19565b5f845461105481610eb4565b60018216801561106b5760018114611080576110ad565b60ff19831685528115158202850193506110ad565b875f5260205f205f5b838110156110a557815487820152600190910190602001611089565b505081850193505b5091979650505050505050565b604081525f6110cc6040830185610e74565b8281036020840152610e6b8185610e74565b5f602082840312156110ee575f5ffd5b815180151581146110fd575f5ffd5b9392505050565b634e487b7160e01b5f52603260045260245ffd5b606081525f61112a6060830186610e74565b82810360208401525f855461113e81610eb4565b8084526001821680156111585760018114611174576111a8565b60ff1983166020860152602082151560051b86010193506111a8565b885f5260205f205f5b8381101561119f5781546020828901015260018201915060208101905061117d565b86016020019450505b50505083810360408501526111bd8186610e74565b979650505050505050565b5f602082840312156111d8575f5ffd5b5051919050565b5f610a356111ed8386610e19565b84610e19565b601760f91b81525f6112086001830186610e19565b605b60f81b815261121c6001820186610e19565b9050612e9760f11b81526112336002820185610e19565b9695505050505050565b5f6001820161124e5761124e611016565b5060010190565b634e487b7160e01b5f52601260045260245ffd5b5f8261127757611277611255565b500490565b5f8261128a5761128a611255565b500690565b8082018082111561095957610959611016565b611e65806112af5f395ff3fe608060405234801561000f575f5ffd5b506004361061012f575f3560e01c8063916a17c6116100ad578063bbf939521161007d578063f11fa17211610063578063f11fa1721461024f578063fa7626d414610257578063fad06b8f14610264575f5ffd5b8063bbf939521461023d578063e20c9f7114610247575f5ffd5b8063916a17c614610200578063b0464fdc14610215578063b5508aa91461021d578063ba414fa614610225575f5ffd5b80633e5e3c231161010257806344badbb6116100e857806344badbb6146101b657806366d9a9a0146101d657806385226c81146101eb575f5ffd5b80633e5e3c23146101a65780633f7286f4146101ae575f5ffd5b80630813852a146101335780631c0da81f1461015c5780631ed7831c1461017c5780632ade388014610191575b5f5ffd5b61014661014136600461164d565b610277565b6040516101539190611702565b60405180910390f35b61016f61016a36600461164d565b6102c2565b6040516101539190611765565b610184610334565b6040516101539190611777565b6101996103a1565b6040516101539190611829565b6101846104ea565b610184610555565b6101c96101c436600461164d565b6105c0565b60405161015391906118ad565b6101de610603565b6040516101539190611940565b6101f361077c565b60405161015391906119be565b610208610847565b60405161015391906119d0565b61020861094a565b6101f3610a4d565b61022d610b18565b6040519015158152602001610153565b610245610be8565b005b610184610d31565b610245610d9c565b601f5461022d9060ff1681565b6101c961027236600461164d565b610e4e565b60606102ba8484846040518060400160405280600381526020017f6865780000000000000000000000000000000000000000000000000000000000815250610e91565b949350505050565b60605f6102d0858585610277565b90505f5b6102de8585611a81565b81101561032b57828282815181106102f8576102f8611a94565b6020026020010151604051602001610311929190611ad8565b60408051601f1981840301815291905292506001016102d4565b50509392505050565b6060601680548060200260200160405190810160405280929190818152602001828054801561039757602002820191905f5260205f20905b815473ffffffffffffffffffffffffffffffffffffffff16815260019091019060200180831161036c575b5050505050905090565b6060601e805480602002602001604051908101604052809291908181526020015f905b828210156104e1575f848152602080822060408051808201825260028702909201805473ffffffffffffffffffffffffffffffffffffffff168352600181018054835181870281018701909452808452939591948681019491929084015b828210156104ca578382905f5260205f2001805461043f90611aec565b80601f016020809104026020016040519081016040528092919081815260200182805461046b90611aec565b80156104b65780601f1061048d576101008083540402835291602001916104b6565b820191905f5260205f20905b81548152906001019060200180831161049957829003601f168201915b505050505081526020019060010190610422565b5050505081525050815260200190600101906103c4565b50505050905090565b6060601880548060200260200160405190810160405280929190818152602001828054801561039757602002820191905f5260205f2090815473ffffffffffffffffffffffffffffffffffffffff16815260019091019060200180831161036c575050505050905090565b6060601780548060200260200160405190810160405280929190818152602001828054801561039757602002820191905f5260205f2090815473ffffffffffffffffffffffffffffffffffffffff16815260019091019060200180831161036c575050505050905090565b60606102ba8484846040518060400160405280600981526020017f6469676573745f6c650000000000000000000000000000000000000000000000815250610ff2565b6060601b805480602002602001604051908101604052809291908181526020015f905b828210156104e1578382905f5260205f2090600202016040518060400160405290815f8201805461065690611aec565b80601f016020809104026020016040519081016040528092919081815260200182805461068290611aec565b80156106cd5780601f106106a4576101008083540402835291602001916106cd565b820191905f5260205f20905b8154815290600101906020018083116106b057829003601f168201915b505050505081526020016001820180548060200260200160405190810160405280929190818152602001828054801561076457602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916815260200190600401906020826003010492830192600103820291508084116107115790505b50505050508152505081526020019060010190610626565b6060601a805480602002602001604051908101604052809291908181526020015f905b828210156104e1578382905f5260205f200180546107bc90611aec565b80601f01602080910402602001604051908101604052809291908181526020018280546107e890611aec565b80156108335780601f1061080a57610100808354040283529160200191610833565b820191905f5260205f20905b81548152906001019060200180831161081657829003601f168201915b50505050508152602001906001019061079f565b6060601d805480602002602001604051908101604052809291908181526020015f905b828210156104e1575f84815260209081902060408051808201825260028602909201805473ffffffffffffffffffffffffffffffffffffffff16835260018101805483518187028101870190945280845293949193858301939283018282801561093257602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916815260200190600401906020826003010492830192600103820291508084116108df5790505b5050505050815250508152602001906001019061086a565b6060601c805480602002602001604051908101604052809291908181526020015f905b828210156104e1575f84815260209081902060408051808201825260028602909201805473ffffffffffffffffffffffffffffffffffffffff168352600181018054835181870281018701909452808452939491938583019392830182828015610a3557602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916815260200190600401906020826003010492830192600103820291508084116109e25790505b5050505050815250508152602001906001019061096d565b60606019805480602002602001604051908101604052809291908181526020015f905b828210156104e1578382905f5260205f20018054610a8d90611aec565b80601f0160208091040260200160405190810160405280929190818152602001828054610ab990611aec565b8015610b045780601f10610adb57610100808354040283529160200191610b04565b820191905f5260205f20905b815481529060010190602001808311610ae757829003601f168201915b505050505081526020019060010190610a70565b6008545f9060ff1615610b2f575060085460ff1690565b6040517f667f9d70000000000000000000000000000000000000000000000000000000008152737109709ecfa91a80626ff3989d68f67f5b1dd12d600482018190527f6661696c6564000000000000000000000000000000000000000000000000000060248301525f9163667f9d7090604401602060405180830381865afa158015610bbd573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610be19190611b3d565b1415905090565b610caf601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663b25b9b0060245460256021600381548110610c4257610c42611a94565b905f5260205f20016040518463ffffffff1660e01b8152600401610c6893929190611c29565b602060405180830381865afa158015610c83573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610ca79190611b3d565b602654611140565b610d2f601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663b25b9b006024546021600381548110610d0757610d07611a94565b905f5260205f200160256040518463ffffffff1660e01b8152600401610c6893929190611c29565b565b6060601580548060200260200160405190810160405280929190818152602001828054801561039757602002820191905f5260205f2090815473ffffffffffffffffffffffffffffffffffffffff16815260019091019060200180831161036c575050505050905090565b610df6601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663b25b9b0060245460256022600381548110610c4257610c42611a94565b610d2f601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663b25b9b006024546022600381548110610d0757610d07611a94565b60606102ba8484846040518060400160405280600681526020017f68656967687400000000000000000000000000000000000000000000000000008152506111c3565b6060610e9d8484611a81565b67ffffffffffffffff811115610eb557610eb56115c8565b604051908082528060200260200182016040528015610ee857816020015b6060815260200190600190039081610ed35790505b509050835b83811015610fe957610fbb86610f0283611311565b85604051602001610f1593929190611c5d565b60405160208183030381529060405260208054610f3190611aec565b80601f0160208091040260200160405190810160405280929190818152602001828054610f5d90611aec565b8015610fa85780601f10610f7f57610100808354040283529160200191610fa8565b820191905f5260205f20905b815481529060010190602001808311610f8b57829003601f168201915b505050505061144290919063ffffffff16565b82610fc68784611a81565b81518110610fd657610fd6611a94565b6020908102919091010152600101610eed565b50949350505050565b6060610ffe8484611a81565b67ffffffffffffffff811115611016576110166115c8565b60405190808252806020026020018201604052801561103f578160200160208202803683370190505b509050835b83811015610fe9576111128661105983611311565b8560405160200161106c93929190611c5d565b6040516020818303038152906040526020805461108890611aec565b80601f01602080910402602001604051908101604052809291908181526020018280546110b490611aec565b80156110ff5780601f106110d6576101008083540402835291602001916110ff565b820191905f5260205f20905b8154815290600101906020018083116110e257829003601f168201915b50505050506114e190919063ffffffff16565b8261111d8784611a81565b8151811061112d5761112d611a94565b6020908102919091010152600101611044565b6040517f7c84c69b0000000000000000000000000000000000000000000000000000000081526004810183905260248101829052737109709ecfa91a80626ff3989d68f67f5b1dd12d90637c84c69b906044015f6040518083038186803b1580156111a9575f5ffd5b505afa1580156111bb573d5f5f3e3d5ffd5b505050505050565b60606111cf8484611a81565b67ffffffffffffffff8111156111e7576111e76115c8565b604051908082528060200260200182016040528015611210578160200160208202803683370190505b509050835b83811015610fe9576112e38661122a83611311565b8560405160200161123d93929190611c5d565b6040516020818303038152906040526020805461125990611aec565b80601f016020809104026020016040519081016040528092919081815260200182805461128590611aec565b80156112d05780601f106112a7576101008083540402835291602001916112d0565b820191905f5260205f20905b8154815290600101906020018083116112b357829003601f168201915b505050505061157490919063ffffffff16565b826112ee8784611a81565b815181106112fe576112fe611a94565b6020908102919091010152600101611215565b6060815f0361135357505060408051808201909152600181527f3000000000000000000000000000000000000000000000000000000000000000602082015290565b815f5b811561137c578061136681611cf0565b91506113759050600a83611d54565b9150611356565b5f8167ffffffffffffffff811115611396576113966115c8565b6040519080825280601f01601f1916602001820160405280156113c0576020820181803683370190505b5090505b84156102ba576113d5600183611a81565b91506113e2600a86611d67565b6113ed906030611d7a565b60f81b81838151811061140257611402611a94565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff191690815f1a90535061143b600a86611d54565b94506113c4565b6040517ffd921be8000000000000000000000000000000000000000000000000000000008152606090737109709ecfa91a80626ff3989d68f67f5b1dd12d9063fd921be8906114979086908690600401611d8d565b5f60405180830381865afa1580156114b1573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d908101601f191682016040526114d89190810190611dba565b90505b92915050565b6040517f1777e59d0000000000000000000000000000000000000000000000000000000081525f90737109709ecfa91a80626ff3989d68f67f5b1dd12d90631777e59d906115359086908690600401611d8d565b602060405180830381865afa158015611550573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906114d89190611b3d565b6040517faddde2b60000000000000000000000000000000000000000000000000000000081525f90737109709ecfa91a80626ff3989d68f67f5b1dd12d9063addde2b6906115359086908690600401611d8d565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b604051601f8201601f1916810167ffffffffffffffff8111828210171561161e5761161e6115c8565b604052919050565b5f67ffffffffffffffff82111561163f5761163f6115c8565b50601f01601f191660200190565b5f5f5f6060848603121561165f575f5ffd5b833567ffffffffffffffff811115611675575f5ffd5b8401601f81018613611685575f5ffd5b803561169861169382611626565b6115f5565b8181528760208385010111156116ac575f5ffd5b816020840160208301375f602092820183015297908601359650604090950135949350505050565b5f81518084528060208401602086015e5f602082860101526020601f19601f83011685010191505092915050565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b8281101561175957603f198786030184526117448583516116d4565b94506020938401939190910190600101611728565b50929695505050505050565b602081525f6114d860208301846116d4565b602080825282518282018190525f918401906040840190835b818110156117c457835173ffffffffffffffffffffffffffffffffffffffff16835260209384019390920191600101611790565b509095945050505050565b5f82825180855260208501945060208160051b830101602085015f5b8381101561181d57601f198584030188526118078383516116d4565b60209889019890935091909101906001016117eb565b50909695505050505050565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b8281101561175957603f19878603018452815173ffffffffffffffffffffffffffffffffffffffff8151168652602081015190506040602087015261189760408701826117cf565b955050602093840193919091019060010161184f565b602080825282518282018190525f918401906040840190835b818110156117c45783518352602093840193909201916001016118c6565b5f8151808452602084019350602083015f5b828110156119365781517fffffffff00000000000000000000000000000000000000000000000000000000168652602095860195909101906001016118f6565b5093949350505050565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b8281101561175957603f19878603018452815180516040875261198c60408801826116d4565b90506020820151915086810360208801526119a781836118e4565b965050506020938401939190910190600101611966565b602081525f6114d860208301846117cf565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b8281101561175957603f19878603018452815173ffffffffffffffffffffffffffffffffffffffff81511686526020810151905060406020870152611a3e60408701826118e4565b95505060209384019391909101906001016119f6565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b818103818111156114db576114db611a54565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b5f81518060208401855e5f93019283525090919050565b5f6102ba611ae68386611ac1565b84611ac1565b600181811c90821680611b0057607f821691505b602082108103611b37577f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b50919050565b5f60208284031215611b4d575f5ffd5b5051919050565b80545f90600181811c90821680611b6c57607f821691505b602082108103611ba3577f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b81865260208601818015611bbe5760018114611bf257611c1e565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff008516825283151560051b82019550611c1e565b5f878152602090205f5b85811015611c1857815484820152600190910190602001611bfc565b83019650505b505050505092915050565b838152606060208201525f611c416060830185611b54565b8281036040840152611c538185611b54565b9695505050505050565b7f2e0000000000000000000000000000000000000000000000000000000000000081525f611c8e6001830186611ac1565b7f5b000000000000000000000000000000000000000000000000000000000000008152611cbe6001820186611ac1565b90507f5d2e0000000000000000000000000000000000000000000000000000000000008152611c536002820185611ac1565b5f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8203611d2057611d20611a54565b5060010190565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b5f82611d6257611d62611d27565b500490565b5f82611d7557611d75611d27565b500690565b808201808211156114db576114db611a54565b604081525f611d9f60408301856116d4565b8281036020840152611db181856116d4565b95945050505050565b5f60208284031215611dca575f5ffd5b815167ffffffffffffffff811115611de0575f5ffd5b8201601f81018413611df0575f5ffd5b8051611dfe61169382611626565b818152856020838501011115611e12575f5ffd5b8160208401602083015e5f9181016020019190915294935050505056fea2646970667358221220b3e97032b70e38ad1abc87d257177cde0208ee551d9bfc1a2585977d4946a36164736f6c634300081c0033608060405234801561000f575f5ffd5b5060405161293b38038061293b83398101604081905261002e9161032b565b82828282828261003f835160501490565b6100845760405162461bcd60e51b81526020600482015260116024820152704261642067656e6573697320626c6f636b60781b60448201526064015b60405180910390fd5b5f61008e84610166565b905062ffffff8216156101095760405162461bcd60e51b815260206004820152603d60248201527f506572696f64207374617274206861736820646f6573206e6f7420686176652060448201527f776f726b2e2048696e743a2077726f6e672062797465206f726465723f000000606482015260840161007b565b5f818155600182905560028290558181526004602052604090208390556101326107e0846103fe565b61013c9084610425565b5f8381526004602052604090205561015384610226565b600555506105bd98505050505050505050565b5f600280836040516101789190610438565b602060405180830381855afa158015610193573d5f5f3e3d5ffd5b5050506040513d601f19601f820116820180604052508101906101b6919061044e565b6040516020016101c891815260200190565b60408051601f19818403018152908290526101e291610438565b602060405180830381855afa1580156101fd573d5f5f3e3d5ffd5b5050506040513d601f19601f82011682018060405250810190610220919061044e565b92915050565b5f61022061023383610238565b610243565b5f6102208282610253565b5f61022061ffff60d01b836102f7565b5f8061026a610263846048610465565b8590610309565b60e81c90505f8461027c85604b610465565b8151811061028c5761028c610478565b016020015160f81c90505f6102be835f60108262ffffff16901c8261ff001660108462ffffff16901b17179050919050565b62ffffff1690505f6102d160038461048c565b60ff1690506102e281610100610588565b6102ec9083610593565b979650505050505050565b5f61030282846105aa565b9392505050565b5f6103028383016020015190565b634e487b7160e01b5f52604160045260245ffd5b5f5f5f6060848603121561033d575f5ffd5b83516001600160401b03811115610352575f5ffd5b8401601f81018613610362575f5ffd5b80516001600160401b0381111561037b5761037b610317565b604051601f8201601f19908116603f011681016001600160401b03811182821017156103a9576103a9610317565b6040528181528282016020018810156103c0575f5ffd5b8160208401602083015e5f6020928201830152908601516040909601519097959650949350505050565b634e487b7160e01b5f52601260045260245ffd5b5f8261040c5761040c6103ea565b500690565b634e487b7160e01b5f52601160045260245ffd5b8181038181111561022057610220610411565b5f82518060208501845e5f920191825250919050565b5f6020828403121561045e575f5ffd5b5051919050565b8082018082111561022057610220610411565b634e487b7160e01b5f52603260045260245ffd5b60ff828116828216039081111561022057610220610411565b6001815b60018411156104e0578085048111156104c4576104c4610411565b60018416156104d257908102905b60019390931c9280026104a9565b935093915050565b5f826104f657506001610220565b8161050257505f610220565b816001811461051857600281146105225761053e565b6001915050610220565b60ff84111561053357610533610411565b50506001821b610220565b5060208310610133831016604e8410600b8410161715610561575081810a610220565b61056d5f1984846104a5565b805f190482111561058057610580610411565b029392505050565b5f61030283836104e8565b808202811582820484141761022057610220610411565b5f826105b8576105b86103ea565b500490565b612371806105ca5f395ff3fe608060405234801561000f575f5ffd5b5060043610610115575f3560e01c806370d53c18116100ad578063b985621a1161007d578063e3d8d8d811610063578063e3d8d8d814610222578063e471e72c14610229578063f58db06f1461023c575f5ffd5b8063b985621a14610207578063c58242cd1461021a575f5ffd5b806370d53c18146101b157806374c3a3a9146101ce5780637fa637fc146101e1578063b25b9b00146101f4575f5ffd5b80632e4f161a116100e85780632e4f161a1461015557806330017b3b1461017857806360b5c3901461018b57806365da41b91461019e575f5ffd5b806305d09a7014610119578063113764be1461012e5780631910d973146101455780632b97be241461014d575b5f5ffd5b61012c610127366004611d7b565b6102a8565b005b6005545b6040519081526020015b60405180910390f35b600154610132565b600654610132565b610168610163366004611e0c565b6104e1565b604051901515815260200161013c565b610132610186366004611e3b565b6104f9565b610132610199366004611e5b565b61050d565b6101686101ac366004611e72565b610517565b6101b9600481565b60405163ffffffff909116815260200161013c565b6101686101dc366004611ede565b6106c3565b6101686101ef366004611f5f565b610838565b610132610202366004611ffe565b610a17565b610168610215366004612077565b610a94565b600254610132565b5f54610132565b61012c6102373660046120a0565b610aaa565b61012c61024a3660046120d9565b600780547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000169215157fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff169290921761010091151591909102179055565b6102e687878080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610b6892505050565b6103375760405162461bcd60e51b815260206004820152601060248201527f4261642068656164657220626c6f636b0000000000000000000000000000000060448201526064015b60405180910390fd5b61037585858080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610b6f92505050565b6103c15760405162461bcd60e51b815260206004820152601660248201527f426164206d65726b6c652061727261792070726f6f6600000000000000000000604482015260640161032e565b6104408361040389898080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610b8592505050565b87878080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250889250610b91915050565b61048c5760405162461bcd60e51b815260206004820152601360248201527f42616420696e636c7573696f6e2070726f6f6600000000000000000000000000604482015260640161032e565b5f6104cb88888080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610bc392505050565b90506104d78183610aaa565b5050505050505050565b5f6104ee85858585610c9b565b90505b949350505050565b5f6105048383610d35565b90505b92915050565b5f61050782610da7565b5f61055683838080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610e5592505050565b6105c85760405162461bcd60e51b815260206004820152602b60248201527f486561646572206172726179206c656e677468206d757374206265206469766960448201527f7369626c65206279203830000000000000000000000000000000000000000000606482015260840161032e565b61060685858080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610b6892505050565b6106525760405162461bcd60e51b815260206004820152601760248201527f416e63686f72206d757374206265203830206279746573000000000000000000604482015260640161032e565b6104ee85858080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525050604080516020601f890181900481028201810190925287815292508791508690819084018382808284375f9201829052509250610e64915050565b5f61070284848080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610b6892505050565b8015610747575061074786868080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610b6892505050565b6107b95760405162461bcd60e51b815260206004820152602e60248201527f42616420617267732e20436865636b2068656164657220616e6420617272617960448201527f2062797465206c656e677468732e000000000000000000000000000000000000606482015260840161032e565b61082d8787878080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525050604080516020601f8b0181900481028201810190925289815292508991508890819084018382808284375f92019190915250889250611251915050565b979650505050505050565b5f61087787878080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610b6892505050565b80156108bc57506108bc85858080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610b6892505050565b8015610901575061090183838080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610e5592505050565b6109735760405162461bcd60e51b815260206004820152602e60248201527f42616420617267732e20436865636b2068656164657220616e6420617272617960448201527f2062797465206c656e677468732e000000000000000000000000000000000000606482015260840161032e565b61082d87878080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525050604080516020601f8b0181900481028201810190925289815292508991508890819084018382808284375f9201919091525050604080516020601f8a0181900481028201810190925288815292508891508790819084018382808284375f920191909152506114ee92505050565b5f610a8a8686868080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525050604080516020601f8a0181900481028201810190925288815292508891508790819084018382808284375f9201919091525061178092505050565b9695505050505050565b5f610aa0848484611911565b90505b9392505050565b5f610ab460025490565b9050610ac38382610800611911565b610b0f5760405162461bcd60e51b815260206004820152601b60248201527f47434420646f6573206e6f7420636f6e6669726d206865616465720000000000604482015260640161032e565b60ff821660081015610b635760405162461bcd60e51b815260206004820152601a60248201527f496e73756666696369656e7420636f6e6669726d6174696f6e73000000000000604482015260640161032e565b505050565b5160501490565b5f60208251610b7e919061212e565b1592915050565b60448101515f90610507565b5f8385148015610b9f575081155b8015610baa57508251155b15610bb7575060016104f1565b6104ee85848685611941565b5f60028083604051610bd59190612141565b602060405180830381855afa158015610bf0573d5f5f3e3d5ffd5b5050506040513d601f19601f82011682018060405250810190610c139190612157565b604051602001610c2591815260200190565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe081840301815290829052610c5d91612141565b602060405180830381855afa158015610c78573d5f5f3e3d5ffd5b5050506040513d601f19601f820116820180604052508101906105079190612157565b5f8385148015610caa57508285145b15610cb7575060016104f1565b838381815f5b86811015610cff57898314610cde575f838152600360205260409020549294505b898214610cf7575f828152600360205260409020549193505b600101610cbd565b50828403610d13575f9450505050506104f1565b808214610d26575f9450505050506104f1565b50600198975050505050505050565b5f82815b83811015610d59575f918252600360205260409091205490600101610d39565b50806105045760405162461bcd60e51b815260206004820152601060248201527f556e6b6e6f776e20616e636573746f7200000000000000000000000000000000604482015260640161032e565b5f8082815b610db86004600161219b565b63ffffffff16811015610e0c575f828152600460205260408120549350839003610df1575f918252600360205260409091205490610e04565b610dfb81846121b7565b95945050505050565b600101610dac565b5060405162461bcd60e51b815260206004820152600d60248201527f556e6b6e6f776e20626c6f636b00000000000000000000000000000000000000604482015260640161032e565b5f60508251610b7e919061212e565b5f5f610e6f85610bc3565b90505f610e7b82610da7565b90505f610e87866119e6565b90508480610e9c575080610e9a886119e6565b145b610f0d5760405162461bcd60e51b8152602060048201526024808201527f556e6578706563746564207265746172676574206f6e2065787465726e616c2060448201527f63616c6c00000000000000000000000000000000000000000000000000000000606482015260840161032e565b85515f908190815b8181101561120e57610f286050826121ca565b610f339060016121b7565b610f3d90876121b7565b9350610f4b8a8260506119f1565b5f8181526003602052604090205490935061112157846110a1845f8190506008817eff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff16901b600882901c7eff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff161790506010817dffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff16901b601082901c7dffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff161790506020817bffffffff00000000ffffffff00000000ffffffff00000000ffffffff16901b602082901c7bffffffff00000000ffffffff00000000ffffffff00000000ffffffff1617905060408177ffffffffffffffff0000000000000000ffffffffffffffff16901b604082901c77ffffffffffffffff0000000000000000ffffffffffffffff16179050608081901b608082901c179050919050565b11156110ef5760405162461bcd60e51b815260206004820152601b60248201527f48656164657220776f726b20697320696e73756666696369656e740000000000604482015260640161032e565b5f83815260036020526040902087905561110a60048561212e565b5f03611121575f8381526004602052604090208490555b8461112c8b83611a16565b146111795760405162461bcd60e51b815260206004820152601b60248201527f546172676574206368616e67656420756e65787065637465646c790000000000604482015260640161032e565b866111848b83611aaf565b146111f75760405162461bcd60e51b815260206004820152602660248201527f4865616465727320646f206e6f7420666f726d206120636f6e73697374656e7460448201527f20636861696e0000000000000000000000000000000000000000000000000000606482015260840161032e565b82965060508161120791906121b7565b9050610f15565b50816112198b610bc3565b6040517ff90e4f1d9cd0dd55e339411cbc9b152482307c3a23ed64715e4a2858f641a3f5905f90a35060019998505050505050505050565b5f6107e08211156112ca5760405162461bcd60e51b815260206004820152603360248201527f526571756573746564206c696d69742069732067726561746572207468616e2060448201527f3120646966666963756c747920706572696f6400000000000000000000000000606482015260840161032e565b5f6112d484610bc3565b90505f6112e086610bc3565b905060015481146113335760405162461bcd60e51b815260206004820181905260248201527f50617373656420696e2062657374206973206e6f742062657374206b6e6f776e604482015260640161032e565b5f8281526003602052604090205461138d5760405162461bcd60e51b815260206004820152601360248201527f4e6577206265737420697320756e6b6e6f776e00000000000000000000000000604482015260640161032e565b61139b876001548487610c9b565b61140d5760405162461bcd60e51b815260206004820152602960248201527f416e636573746f72206d75737420626520686561766965737420636f6d6d6f6e60448201527f20616e636573746f720000000000000000000000000000000000000000000000606482015260840161032e565b81611419888888611780565b1461148c5760405162461bcd60e51b815260206004820152603360248201527f4e65772062657374206861736820646f6573206e6f742068617665206d6f726560448201527f20776f726b207468616e2070726576696f757300000000000000000000000000606482015260840161032e565b600182905560028790555f6114a086611ac7565b905060055481146114b15760058190555b8783837f3cc13de64df0f0239626235c51a2da251bbc8c85664ecce39263da3ee03f606c60405160405180910390a4506001979650505050505050565b5f5f6115016114fc86610bc3565b610da7565b90505f6115106114fc86610bc3565b905061151e6107e08261212e565b6107df146115945760405162461bcd60e51b815260206004820152603d60248201527f4d7573742070726f7669646520746865206c61737420686561646572206f662060448201527f74686520636c6f73696e6720646966666963756c747920706572696f64000000606482015260840161032e565b6115a0826107df6121b7565b81146116145760405162461bcd60e51b815260206004820152602860248201527f4d7573742070726f766964652065786163746c79203120646966666963756c7460448201527f7920706572696f64000000000000000000000000000000000000000000000000606482015260840161032e565b61161d85611ac7565b61162687611ac7565b146116995760405162461bcd60e51b815260206004820152602760248201527f506572696f642068656164657220646966666963756c7469657320646f206e6f60448201527f74206d6174636800000000000000000000000000000000000000000000000000606482015260840161032e565b5f6116a3856119e6565b90505f6116d56116b2896119e6565b6116bb8a611ad9565b63ffffffff166116ca8a611ad9565b63ffffffff16611b0c565b905081818316146117285760405162461bcd60e51b815260206004820152601960248201527f496e76616c69642072657461726765742070726f766964656400000000000000604482015260640161032e565b5f61173289611ac7565b9050806006541415801561175c57506107e061174f600154610da7565b61175991906121dd565b84115b156117675760068190555b61177388886001610e64565b9998505050505050505050565b5f5f61178b85610da7565b90505f61179a6114fc86610bc3565b90505f6117a96114fc86610bc3565b90508282101580156117bb5750828110155b61182d5760405162461bcd60e51b815260206004820152603060248201527f412064657363656e64616e74206865696768742069732062656c6f772074686560448201527f20616e636573746f722068656967687400000000000000000000000000000000606482015260840161032e565b5f61183a6107e08561212e565b611846856107e06121b7565b61185091906121dd565b90508083108183108115826118625750805b1561187d5761187089610bc3565b9650505050505050610aa3565b818015611888575080155b156118965761187088610bc3565b8180156118a05750805b156118c457838510156118bb576118b688610bc3565b611870565b61187089610bc3565b6118cd88611ac7565b6118d96107e08661212e565b6118e391906121f0565b6118ec8a611ac7565b6118f86107e08861212e565b61190291906121f0565b10156118bb5761187088610bc3565b6007545f9060ff161561192f5750600754610100900460ff16610aa3565b61193a848484611b94565b9050610aa3565b5f60208451611950919061212e565b1561195c57505f6104f1565b83515f0361196b57505f6104f1565b81855f5b86518110156119d95761198360028461212e565b6001036119a7576119a061199a8883016020015190565b83611bd5565b91506119c0565b6119bd826119b88984016020015190565b611bd5565b91505b60019290921c916119d26020826121b7565b905061196f565b5090931495945050505050565b5f610507825f611a16565b5f60205f8385602001870160025afa5060205f60205f60025afa50505f519392505050565b5f80611a2d611a268460486121b7565b8590611be0565b60e81c90505f84611a3f85604b6121b7565b81518110611a4f57611a4f612207565b016020015160f81c90505f611a81835f60108262ffffff16901c8261ff001660108462ffffff16901b17179050919050565b62ffffff1690505f611a94600384612234565b60ff169050611aa581610100612330565b61082d90836121f0565b5f610504611abe8360046121b7565b84016020015190565b5f610507611ad4836119e6565b611bee565b5f610507611ae683611c15565b60d881901c63ff00ff001662ff00ff60e89290921c9190911617601081811b91901c1790565b5f80611b188385611c21565b9050611b28621275006004611c7c565b811015611b4057611b3d621275006004611c7c565b90505b611b4e621275006004611c87565b811115611b6657611b63621275006004611c87565b90505b5f611b7e82611b788862010000611c7c565b90611c87565b9050610a8a62010000611b788362127500611c7c565b5f82815b83811015611bca57858203611bb257600192505050610aa3565b5f918252600360205260409091205490600101611b98565b505f95945050505050565b5f6105048383611cfa565b5f6105048383016020015190565b5f6105077bffff000000000000000000000000000000000000000000000000000083611c7c565b5f610507826044611be0565b5f82821115611c725760405162461bcd60e51b815260206004820152601d60248201527f556e646572666c6f7720647572696e67207375627472616374696f6e2e000000604482015260640161032e565b61050482846121dd565b5f61050482846121ca565b5f825f03611c9657505f610507565b611ca082846121f0565b905081611cad84836121ca565b146105075760405162461bcd60e51b815260206004820152601f60248201527f4f766572666c6f7720647572696e67206d756c7469706c69636174696f6e2e00604482015260640161032e565b5f825f528160205260205f60405f60025afa5060205f60205f60025afa50505f5192915050565b5f5f83601f840112611d31575f5ffd5b50813567ffffffffffffffff811115611d48575f5ffd5b602083019150836020828501011115611d5f575f5ffd5b9250929050565b803560ff81168114611d76575f5ffd5b919050565b5f5f5f5f5f5f5f60a0888a031215611d91575f5ffd5b873567ffffffffffffffff811115611da7575f5ffd5b611db38a828b01611d21565b909850965050602088013567ffffffffffffffff811115611dd2575f5ffd5b611dde8a828b01611d21565b9096509450506040880135925060608801359150611dfe60808901611d66565b905092959891949750929550565b5f5f5f5f60808587031215611e1f575f5ffd5b5050823594602084013594506040840135936060013592509050565b5f5f60408385031215611e4c575f5ffd5b50508035926020909101359150565b5f60208284031215611e6b575f5ffd5b5035919050565b5f5f5f5f60408587031215611e85575f5ffd5b843567ffffffffffffffff811115611e9b575f5ffd5b611ea787828801611d21565b909550935050602085013567ffffffffffffffff811115611ec6575f5ffd5b611ed287828801611d21565b95989497509550505050565b5f5f5f5f5f5f60808789031215611ef3575f5ffd5b86359550602087013567ffffffffffffffff811115611f10575f5ffd5b611f1c89828a01611d21565b909650945050604087013567ffffffffffffffff811115611f3b575f5ffd5b611f4789828a01611d21565b979a9699509497949695606090950135949350505050565b5f5f5f5f5f5f60608789031215611f74575f5ffd5b863567ffffffffffffffff811115611f8a575f5ffd5b611f9689828a01611d21565b909750955050602087013567ffffffffffffffff811115611fb5575f5ffd5b611fc189828a01611d21565b909550935050604087013567ffffffffffffffff811115611fe0575f5ffd5b611fec89828a01611d21565b979a9699509497509295939492505050565b5f5f5f5f5f60608688031215612012575f5ffd5b85359450602086013567ffffffffffffffff81111561202f575f5ffd5b61203b88828901611d21565b909550935050604086013567ffffffffffffffff81111561205a575f5ffd5b61206688828901611d21565b969995985093965092949392505050565b5f5f5f60608486031215612089575f5ffd5b505081359360208301359350604090920135919050565b5f5f604083850312156120b1575f5ffd5b823591506120c160208401611d66565b90509250929050565b80358015158114611d76575f5ffd5b5f5f604083850312156120ea575f5ffd5b6120f3836120ca565b91506120c1602084016120ca565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b5f8261213c5761213c612101565b500690565b5f82518060208501845e5f920191825250919050565b5f60208284031215612167575f5ffd5b5051919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b63ffffffff81811683821601908111156105075761050761216e565b808201808211156105075761050761216e565b5f826121d8576121d8612101565b500490565b818103818111156105075761050761216e565b80820281158282048414176105075761050761216e565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b60ff82811682821603908111156105075761050761216e565b6001815b60018411156122885780850481111561226c5761226c61216e565b600184161561227a57908102905b60019390931c928002612251565b935093915050565b5f8261229e57506001610507565b816122aa57505f610507565b81600181146122c057600281146122ca576122e6565b6001915050610507565b60ff8411156122db576122db61216e565b50506001821b610507565b5060208310610133831016604e8410600b8410161715612309575081810a610507565b6123155f19848461224d565b805f19048211156123285761232861216e565b029392505050565b5f610504838361229056fea26469706673582212201142af7e12173b7a99dd453dfc892e01c9c1e5b63659b60c61d3e9d80122f9eb64736f6c634300081c0033706f73745265746172676574436861696e0000000000000000000000000000000000000000000000000000007109709ecfa91a80626ff3989d68f67f5b1dd12d - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"`\x80`@R`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15a\0,W__\xFD[P`@Q\x80`@\x01`@R\x80`\x1C\x81R` \x01\x7FheadersReorgAndRetarget.json\0\0\0\0\x81RP`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k\x05\xCC\xEC\xAD\xCC\xAEm.e\xCD\x0C\xAF`\xA3\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x0F\x81R` \x01n\x0B\x99\xD9[\x99\\\xDA\\\xCB\x9A\x19ZY\xDA\x1D`\x8A\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x19\x81R` \x01\x7F.oldPeriodStart.digest_le\0\0\0\0\0\0\0\x81RP__Q` aZo_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x16c\xD90\xA0\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01/W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01V\x91\x90\x81\x01\x90a\r\xD5V[\x90P_\x81\x86`@Q` \x01a\x01l\x92\x91\x90a\x0E0V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Rc`\xF9\xBB\x11`\xE0\x1B\x82R\x91P_Q` aZo_9_Q\x90_R\x90c`\xF9\xBB\x11\x90a\x01\xAC\x90\x84\x90`\x04\x01a\x0E\xA2V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xC6W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01\xED\x91\x90\x81\x01\x90a\r\xD5V[` \x90a\x01\xFA\x90\x82a\x0F8V[Pa\x02\x91\x85` \x80Ta\x02\x0C\x90a\x0E\xB4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x028\x90a\x0E\xB4V[\x80\x15a\x02\x83W\x80`\x1F\x10a\x02ZWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02\x83V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02fW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x08\xE0\x91PPV[a\x03'\x85` \x80Ta\x02\xA2\x90a\x0E\xB4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\xCE\x90a\x0E\xB4V[\x80\x15a\x03\x19W\x80`\x1F\x10a\x02\xF0Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\x19V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02\xFCW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\t_\x91PPV[a\x03\xBD\x85` \x80Ta\x038\x90a\x0E\xB4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03d\x90a\x0E\xB4V[\x80\x15a\x03\xAFW\x80`\x1F\x10a\x03\x86Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xAFV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\x92W\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\t\xD2\x91PPV[`@Qa\x03\xC9\x90a\x0C\x81V[a\x03\xD5\x93\x92\x91\x90a\x0F\xF2V[`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03\xEEW=__>=_\xFD[P`\x1F`\x01a\x01\0\n\x81T\x81`\x01`\x01`\xA0\x1B\x03\x02\x19\x16\x90\x83`\x01`\x01`\xA0\x1B\x03\x16\x02\x17\x90UPPPPPPPa\x04U`@Q\x80`@\x01`@R\x80`\x10\x81R` \x01o892\xA92\xBA0\xB93\xB2\xBA!\xB40\xB4\xB7`\x81\x1B\x81RP_`\x05a\n\x06` \x1B` \x1CV[\x80Qa\x04i\x91`!\x91` \x90\x91\x01\x90a\x0C\x8EV[P`@\x80Q\x80\x82\x01\x90\x91R`\x11\x81R_Q` aZO_9_Q\x90_R` \x82\x01Ra\x04\x97\x90_`\x08a\n\x06V[\x80Qa\x04\xAB\x91`\"\x91` \x90\x91\x01\x90a\x0C\x8EV[P`@\x80Q\x80\x82\x01\x90\x91R`\x11\x81R_Q` aZO_9_Q\x90_R` \x82\x01Ra\x04\xE3\x90_a\x04\xDE`\x02`\x08a\x10*V[a\n\x06V[\x80Qa\x04\xF7\x91`#\x91` \x90\x91\x01\x90a\x0C\x8EV[P_a\x053`@Q\x80`@\x01`@R\x80`\x10\x81R` \x01o892\xA92\xBA0\xB93\xB2\xBA!\xB40\xB4\xB7`\x81\x1B\x81RP_`\x05a\n=` \x1B` \x1CV[\x90P_a\x05j`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01_Q` aZO_9_Q\x90_R\x81RP_`\x08a\n=` \x1B` \x1CV[\x90P_a\x05\xA7`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01_Q` aZO_9_Q\x90_R\x81RP_`\x02`\x08a\x05\xA2\x91\x90a\x10*V[a\n=V[\x90Pa\x05\xE4`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01q\x05\xCD\xEEN\r\x0C-\xCB\xE6\x86f\xE6\x86\xE7\x05\xCD\x0C\xAF`s\x1B\x81RP` \x80Ta\x02\x0C\x90a\x0E\xB4V[`%\x90a\x05\xF1\x90\x82a\x0F8V[Pa\x068`@Q\x80`@\x01`@R\x80`\x18\x81R` \x01\x7F.orphan_437478.digest_le\0\0\0\0\0\0\0\0\x81RP` \x80Ta\x038\x90a\x0E\xB4V[`&U`@Q_\x90a\x06Q\x90\x83\x90`%\x90` \x01a\x10=V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90P_a\x06\x98`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k\x05\xCC\xEC\xAD\xCC\xAEm.e\xCD\x0C\xAF`\xA3\x1B\x81RP` \x80Ta\x02\x0C\x90a\x0E\xB4V[\x90Pa\x06\xD5`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01q.genesis.digest_le`p\x1B\x81RP` \x80Ta\x038\x90a\x0E\xB4V[`$\x81\x90UP_a\x07\"`@Q\x80`@\x01`@R\x80`\x13\x81R` \x01\x7F.oldPeriodStart.hex\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x80Ta\x02\x0C\x90a\x0E\xB4V[`\x1FT`@Qce\xDAA\xB9`\xE0\x1B\x81R\x91\x92Pa\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90ce\xDAA\xB9\x90a\x07Z\x90\x85\x90\x8A\x90`\x04\x01a\x10\xBAV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x07vW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x9A\x91\x90a\x10\xDEV[P`\x1FTa\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16c\x7F\xA67\xFC\x82`!a\x07\xC0`\x01`\x05a\x10*V[\x81T\x81\x10a\x07\xD0Wa\x07\xD0a\x11\x04V[\x90_R` _ \x01\x88`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x07\xF7\x93\x92\x91\x90a\x11\x18V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x08\x13W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x087\x91\x90a\x10\xDEV[P`\x1FTa\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16c\x7F\xA67\xFC\x82`!a\x08]`\x01`\x05a\x10*V[\x81T\x81\x10a\x08mWa\x08ma\x11\x04V[\x90_R` _ \x01\x86`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x08\x94\x93\x92\x91\x90a\x11\x18V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x08\xB0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\xD4\x91\x90a\x10\xDEV[PPPPPPPa\x12\xA2V[`@Qc\x1F\xB2C}`\xE3\x1B\x81R``\x90_Q` aZo_9_Q\x90_R\x90c\xFD\x92\x1B\xE8\x90a\t\x15\x90\x86\x90\x86\x90`\x04\x01a\x10\xBAV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\t/W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\tV\x91\x90\x81\x01\x90a\r\xD5V[\x90P[\x92\x91PPV[`@QcV\xEE\xF1[`\xE1\x1B\x81R_\x90_Q` aZo_9_Q\x90_R\x90c\xAD\xDD\xE2\xB6\x90a\t\x93\x90\x86\x90\x86\x90`\x04\x01a\x10\xBAV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\t\xAEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\tV\x91\x90a\x11\xC8V[`@Qc\x17w\xE5\x9D`\xE0\x1B\x81R_\x90_Q` aZo_9_Q\x90_R\x90c\x17w\xE5\x9D\x90a\t\x93\x90\x86\x90\x86\x90`\x04\x01a\x10\xBAV[``a\n5\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01b\r\x0C\xAF`\xEB\x1B\x81RPa\n\xAF` \x1B` \x1CV[\x94\x93PPPPV[``_a\nK\x85\x85\x85a\n\x06V[\x90P_[a\nY\x85\x85a\x10*V[\x81\x10\x15a\n\xA6W\x82\x82\x82\x81Q\x81\x10a\nsWa\nsa\x11\x04V[` \x02` \x01\x01Q`@Q` \x01a\n\x8C\x92\x91\x90a\x11\xDFV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\nOV[PP\x93\x92PPPV[``a\n\xBB\x84\x84a\x10*V[`\x01`\x01`@\x1B\x03\x81\x11\x15a\n\xD2Wa\n\xD2a\rLV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0B\x05W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\n\xF0W\x90P[P\x90P\x83[\x83\x81\x10\x15a\x0B|Wa\x0BN\x86a\x0B\x1F\x83a\x0B\x85V[\x85`@Q` \x01a\x0B2\x93\x92\x91\x90a\x11\xF3V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x02\x0C\x90a\x0E\xB4V[\x82a\x0BY\x87\x84a\x10*V[\x81Q\x81\x10a\x0BiWa\x0Bia\x11\x04V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x0B\nV[P\x94\x93PPPPV[``\x81_\x03a\x0B\xABWPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R`\x03`\xFC\x1B` \x82\x01R\x90V[\x81_[\x81\x15a\x0B\xD4W\x80a\x0B\xBE\x81a\x12=V[\x91Pa\x0B\xCD\x90P`\n\x83a\x12iV[\x91Pa\x0B\xAEV[_\x81`\x01`\x01`@\x1B\x03\x81\x11\x15a\x0B\xEDWa\x0B\xEDa\rLV[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x0C\x17W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\n5Wa\x0C,`\x01\x83a\x10*V[\x91Pa\x0C9`\n\x86a\x12|V[a\x0CD\x90`0a\x12\x8FV[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x0CYWa\x0CYa\x11\x04V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SPa\x0Cz`\n\x86a\x12iV[\x94Pa\x0C\x1BV[a);\x80a1\x14\x839\x01\x90V[\x82\x80T\x82\x82U\x90_R` _ \x90\x81\x01\x92\x82\x15a\x0C\xD2W\x91` \x02\x82\x01[\x82\x81\x11\x15a\x0C\xD2W\x82Q\x82\x90a\x0C\xC2\x90\x82a\x0F8V[P\x91` \x01\x91\x90`\x01\x01\x90a\x0C\xACV[Pa\x0C\xDE\x92\x91Pa\x0C\xE2V[P\x90V[\x80\x82\x11\x15a\x0C\xDEW_a\x0C\xF5\x82\x82a\x0C\xFEV[P`\x01\x01a\x0C\xE2V[P\x80Ta\r\n\x90a\x0E\xB4V[_\x82U\x80`\x1F\x10a\r\x19WPPV[`\x1F\x01` \x90\x04\x90_R` _ \x90\x81\x01\x90a\r5\x91\x90a\r8V[PV[[\x80\x82\x11\x15a\x0C\xDEW_\x81U`\x01\x01a\r9V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x80`\x01`\x01`@\x1B\x03\x84\x11\x15a\ryWa\rya\rLV[P`@Q`\x1F\x19`\x1F\x85\x01\x81\x16`?\x01\x16\x81\x01\x81\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17\x15a\r\xA7Wa\r\xA7a\rLV[`@R\x83\x81R\x90P\x80\x82\x84\x01\x85\x10\x15a\r\xBEW__\xFD[\x83\x83` \x83\x01^_` \x85\x83\x01\x01RP\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\r\xE5W__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\r\xFAW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x0E\nW__\xFD[a\n5\x84\x82Q` \x84\x01a\r`V[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x0E;\x82\x85a\x0E\x19V[\x7F/test/fullRelay/testData/\0\0\0\0\0\0\0\x81Ra\x0Ek`\x19\x82\x01\x85a\x0E\x19V[\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R_a\tV` \x83\x01\x84a\x0EtV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x0E\xC8W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x0E\xE6WcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\x0F3W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x0F\x11WP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x0F0W_\x81U`\x01\x01a\x0F\x1DV[PP[PPPV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x0FQWa\x0FQa\rLV[a\x0Fe\x81a\x0F_\x84Ta\x0E\xB4V[\x84a\x0E\xECV[` `\x1F\x82\x11`\x01\x81\x14a\x0F\x97W_\x83\x15a\x0F\x80WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x0F0V[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x0F\xC6W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x0F\xA6V[P\x84\x82\x10\x15a\x0F\xE3W\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[``\x81R_a\x10\x04``\x83\x01\x86a\x0EtV[` \x83\x01\x94\x90\x94RP`@\x01R\x91\x90PV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\tYWa\tYa\x10\x16V[_a\x10H\x82\x85a\x0E\x19V[_\x84Ta\x10T\x81a\x0E\xB4V[`\x01\x82\x16\x80\x15a\x10kW`\x01\x81\x14a\x10\x80Wa\x10\xADV[`\xFF\x19\x83\x16\x85R\x81\x15\x15\x82\x02\x85\x01\x93Pa\x10\xADV[\x87_R` _ _[\x83\x81\x10\x15a\x10\xA5W\x81T\x87\x82\x01R`\x01\x90\x91\x01\x90` \x01a\x10\x89V[PP\x81\x85\x01\x93P[P\x91\x97\x96PPPPPPPV[`@\x81R_a\x10\xCC`@\x83\x01\x85a\x0EtV[\x82\x81\x03` \x84\x01Ra\x0Ek\x81\x85a\x0EtV[_` \x82\x84\x03\x12\x15a\x10\xEEW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x10\xFDW__\xFD[\x93\x92PPPV[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[``\x81R_a\x11*``\x83\x01\x86a\x0EtV[\x82\x81\x03` \x84\x01R_\x85Ta\x11>\x81a\x0E\xB4V[\x80\x84R`\x01\x82\x16\x80\x15a\x11XW`\x01\x81\x14a\x11tWa\x11\xA8V[`\xFF\x19\x83\x16` \x86\x01R` \x82\x15\x15`\x05\x1B\x86\x01\x01\x93Pa\x11\xA8V[\x88_R` _ _[\x83\x81\x10\x15a\x11\x9FW\x81T` \x82\x89\x01\x01R`\x01\x82\x01\x91P` \x81\x01\x90Pa\x11}V[\x86\x01` \x01\x94PP[PPP\x83\x81\x03`@\x85\x01Ra\x11\xBD\x81\x86a\x0EtV[\x97\x96PPPPPPPV[_` \x82\x84\x03\x12\x15a\x11\xD8W__\xFD[PQ\x91\x90PV[_a\n5a\x11\xED\x83\x86a\x0E\x19V[\x84a\x0E\x19V[`\x17`\xF9\x1B\x81R_a\x12\x08`\x01\x83\x01\x86a\x0E\x19V[`[`\xF8\x1B\x81Ra\x12\x1C`\x01\x82\x01\x86a\x0E\x19V[\x90Pa.\x97`\xF1\x1B\x81Ra\x123`\x02\x82\x01\x85a\x0E\x19V[\x96\x95PPPPPPV[_`\x01\x82\x01a\x12NWa\x12Na\x10\x16V[P`\x01\x01\x90V[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x12wWa\x12wa\x12UV[P\x04\x90V[_\x82a\x12\x8AWa\x12\x8Aa\x12UV[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a\tYWa\tYa\x10\x16V[a\x1Ee\x80a\x12\xAF_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01/W_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\xADW\x80c\xBB\xF99R\x11a\0}W\x80c\xF1\x1F\xA1r\x11a\0cW\x80c\xF1\x1F\xA1r\x14a\x02OW\x80c\xFAv&\xD4\x14a\x02WW\x80c\xFA\xD0k\x8F\x14a\x02dW__\xFD[\x80c\xBB\xF99R\x14a\x02=W\x80c\xE2\x0C\x9Fq\x14a\x02GW__\xFD[\x80c\x91j\x17\xC6\x14a\x02\0W\x80c\xB0FO\xDC\x14a\x02\x15W\x80c\xB5P\x8A\xA9\x14a\x02\x1DW\x80c\xBAAO\xA6\x14a\x02%W__\xFD[\x80c>^<#\x11a\x01\x02W\x80cD\xBA\xDB\xB6\x11a\0\xE8W\x80cD\xBA\xDB\xB6\x14a\x01\xB6W\x80cf\xD9\xA9\xA0\x14a\x01\xD6W\x80c\x85\"l\x81\x14a\x01\xEBW__\xFD[\x80c>^<#\x14a\x01\xA6W\x80c?r\x86\xF4\x14a\x01\xAEW__\xFD[\x80c\x08\x13\x85*\x14a\x013W\x80c\x1C\r\xA8\x1F\x14a\x01\\W\x80c\x1E\xD7\x83\x1C\x14a\x01|W\x80c*\xDE8\x80\x14a\x01\x91W[__\xFD[a\x01Fa\x01A6`\x04a\x16MV[a\x02wV[`@Qa\x01S\x91\x90a\x17\x02V[`@Q\x80\x91\x03\x90\xF3[a\x01oa\x01j6`\x04a\x16MV[a\x02\xC2V[`@Qa\x01S\x91\x90a\x17eV[a\x01\x84a\x034V[`@Qa\x01S\x91\x90a\x17wV[a\x01\x99a\x03\xA1V[`@Qa\x01S\x91\x90a\x18)V[a\x01\x84a\x04\xEAV[a\x01\x84a\x05UV[a\x01\xC9a\x01\xC46`\x04a\x16MV[a\x05\xC0V[`@Qa\x01S\x91\x90a\x18\xADV[a\x01\xDEa\x06\x03V[`@Qa\x01S\x91\x90a\x19@V[a\x01\xF3a\x07|V[`@Qa\x01S\x91\x90a\x19\xBEV[a\x02\x08a\x08GV[`@Qa\x01S\x91\x90a\x19\xD0V[a\x02\x08a\tJV[a\x01\xF3a\nMV[a\x02-a\x0B\x18V[`@Q\x90\x15\x15\x81R` \x01a\x01SV[a\x02Ea\x0B\xE8V[\0[a\x01\x84a\r1V[a\x02Ea\r\x9CV[`\x1FTa\x02-\x90`\xFF\x16\x81V[a\x01\xC9a\x02r6`\x04a\x16MV[a\x0ENV[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x0E\x91V[\x94\x93PPPPV[``_a\x02\xD0\x85\x85\x85a\x02wV[\x90P_[a\x02\xDE\x85\x85a\x1A\x81V[\x81\x10\x15a\x03+W\x82\x82\x82\x81Q\x81\x10a\x02\xF8Wa\x02\xF8a\x1A\x94V[` \x02` \x01\x01Q`@Q` \x01a\x03\x11\x92\x91\x90a\x1A\xD8V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x02\xD4V[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\xCAW\x83\x82\x90_R` _ \x01\x80Ta\x04?\x90a\x1A\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x04k\x90a\x1A\xECV[\x80\x15a\x04\xB6W\x80`\x1F\x10a\x04\x8DWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x04\xB6V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x04\x99W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x04\"V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x03\xC4V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x0F\xF2V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x06V\x90a\x1A\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06\x82\x90a\x1A\xECV[\x80\x15a\x06\xCDW\x80`\x1F\x10a\x06\xA4Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x06\xCDV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x06\xB0W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07dW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x07\x11W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x06&V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x01\x80Ta\x07\xBC\x90a\x1A\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07\xE8\x90a\x1A\xECV[\x80\x15a\x083W\x80`\x1F\x10a\x08\nWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x083V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x08\x16W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x07\x9FV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\t2W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x08\xDFW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x08jV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\n5W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\t\xE2W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\tmV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x01\x80Ta\n\x8D\x90a\x1A\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n\xB9\x90a\x1A\xECV[\x80\x15a\x0B\x04W\x80`\x1F\x10a\n\xDBWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\x04V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\n\xE7W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\npV[`\x08T_\x90`\xFF\x16\x15a\x0B/WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0B\xBDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\xE1\x91\x90a\x1B=V[\x14\x15\x90P\x90V[a\x0C\xAF`\x1F`\x01\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\xB2[\x9B\0`$T`%`!`\x03\x81T\x81\x10a\x0CBWa\x0CBa\x1A\x94V[\x90_R` _ \x01`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0Ch\x93\x92\x91\x90a\x1C)V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0C\x83W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\xA7\x91\x90a\x1B=V[`&Ta\x11@V[a\r/`\x1F`\x01\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\xB2[\x9B\0`$T`!`\x03\x81T\x81\x10a\r\x07Wa\r\x07a\x1A\x94V[\x90_R` _ \x01`%`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0Ch\x93\x92\x91\x90a\x1C)V[V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[a\r\xF6`\x1F`\x01\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\xB2[\x9B\0`$T`%`\"`\x03\x81T\x81\x10a\x0CBWa\x0CBa\x1A\x94V[a\r/`\x1F`\x01\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\xB2[\x9B\0`$T`\"`\x03\x81T\x81\x10a\r\x07Wa\r\x07a\x1A\x94V[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x11\xC3V[``a\x0E\x9D\x84\x84a\x1A\x81V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0E\xB5Wa\x0E\xB5a\x15\xC8V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0E\xE8W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x0E\xD3W\x90P[P\x90P\x83[\x83\x81\x10\x15a\x0F\xE9Wa\x0F\xBB\x86a\x0F\x02\x83a\x13\x11V[\x85`@Q` \x01a\x0F\x15\x93\x92\x91\x90a\x1C]V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x0F1\x90a\x1A\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F]\x90a\x1A\xECV[\x80\x15a\x0F\xA8W\x80`\x1F\x10a\x0F\x7FWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F\xA8V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\x8BW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x14B\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x0F\xC6\x87\x84a\x1A\x81V[\x81Q\x81\x10a\x0F\xD6Wa\x0F\xD6a\x1A\x94V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x0E\xEDV[P\x94\x93PPPPV[``a\x0F\xFE\x84\x84a\x1A\x81V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10\x16Wa\x10\x16a\x15\xC8V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x10?W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x0F\xE9Wa\x11\x12\x86a\x10Y\x83a\x13\x11V[\x85`@Q` \x01a\x10l\x93\x92\x91\x90a\x1C]V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x10\x88\x90a\x1A\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x10\xB4\x90a\x1A\xECV[\x80\x15a\x10\xFFW\x80`\x1F\x10a\x10\xD6Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x10\xFFV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x10\xE2W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x14\xE1\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x11\x1D\x87\x84a\x1A\x81V[\x81Q\x81\x10a\x11-Wa\x11-a\x1A\x94V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x10DV[`@Q\x7F|\x84\xC6\x9B\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c|\x84\xC6\x9B\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x11\xA9W__\xFD[PZ\xFA\x15\x80\x15a\x11\xBBW=__>=_\xFD[PPPPPPV[``a\x11\xCF\x84\x84a\x1A\x81V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x11\xE7Wa\x11\xE7a\x15\xC8V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x12\x10W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x0F\xE9Wa\x12\xE3\x86a\x12*\x83a\x13\x11V[\x85`@Q` \x01a\x12=\x93\x92\x91\x90a\x1C]V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x12Y\x90a\x1A\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x12\x85\x90a\x1A\xECV[\x80\x15a\x12\xD0W\x80`\x1F\x10a\x12\xA7Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x12\xD0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x12\xB3W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x15t\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x12\xEE\x87\x84a\x1A\x81V[\x81Q\x81\x10a\x12\xFEWa\x12\xFEa\x1A\x94V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x12\x15V[``\x81_\x03a\x13SWPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x13|W\x80a\x13f\x81a\x1C\xF0V[\x91Pa\x13u\x90P`\n\x83a\x1DTV[\x91Pa\x13VV[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x13\x96Wa\x13\x96a\x15\xC8V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x13\xC0W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x02\xBAWa\x13\xD5`\x01\x83a\x1A\x81V[\x91Pa\x13\xE2`\n\x86a\x1DgV[a\x13\xED\x90`0a\x1DzV[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x14\x02Wa\x14\x02a\x1A\x94V[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x14;`\n\x86a\x1DTV[\x94Pa\x13\xC4V[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a\x14\x97\x90\x86\x90\x86\x90`\x04\x01a\x1D\x8DV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x14\xB1W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x14\xD8\x91\x90\x81\x01\x90a\x1D\xBAV[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x155\x90\x86\x90\x86\x90`\x04\x01a\x1D\x8DV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x15PW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x14\xD8\x91\x90a\x1B=V[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x155\x90\x86\x90\x86\x90`\x04\x01a\x1D\x8DV[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x16\x1EWa\x16\x1Ea\x15\xC8V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x16?Wa\x16?a\x15\xC8V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x16_W__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16uW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x16\x85W__\xFD[\x805a\x16\x98a\x16\x93\x82a\x16&V[a\x15\xF5V[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x16\xACW__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x17YW`?\x19\x87\x86\x03\x01\x84Ra\x17D\x85\x83Qa\x16\xD4V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x17(V[P\x92\x96\x95PPPPPPV[` \x81R_a\x14\xD8` \x83\x01\x84a\x16\xD4V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x17\xC4W\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\x17\x90V[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x18\x1DW`\x1F\x19\x85\x84\x03\x01\x88Ra\x18\x07\x83\x83Qa\x16\xD4V[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x17\xEBV[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x17YW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x18\x97`@\x87\x01\x82a\x17\xCFV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x18OV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x17\xC4W\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x18\xC6V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x196W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x18\xF6V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x17YW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x19\x8C`@\x88\x01\x82a\x16\xD4V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x19\xA7\x81\x83a\x18\xE4V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x19fV[` \x81R_a\x14\xD8` \x83\x01\x84a\x17\xCFV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x17YW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1A>`@\x87\x01\x82a\x18\xE4V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x19\xF6V[\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\x14\xDBWa\x14\xDBa\x1ATV[\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x02\xBAa\x1A\xE6\x83\x86a\x1A\xC1V[\x84a\x1A\xC1V[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1B\0W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x1B7W\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x1BMW__\xFD[PQ\x91\x90PV[\x80T_\x90`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1BlW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x1B\xA3W\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[\x81\x86R` \x86\x01\x81\x80\x15a\x1B\xBEW`\x01\x81\x14a\x1B\xF2Wa\x1C\x1EV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x85\x16\x82R\x83\x15\x15`\x05\x1B\x82\x01\x95Pa\x1C\x1EV[_\x87\x81R` \x90 _[\x85\x81\x10\x15a\x1C\x18W\x81T\x84\x82\x01R`\x01\x90\x91\x01\x90` \x01a\x1B\xFCV[\x83\x01\x96PP[PPPPP\x92\x91PPV[\x83\x81R``` \x82\x01R_a\x1CA``\x83\x01\x85a\x1BTV[\x82\x81\x03`@\x84\x01Ra\x1CS\x81\x85a\x1BTV[\x96\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\x81R_a\x1C\x8E`\x01\x83\x01\x86a\x1A\xC1V[\x7F[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x1C\xBE`\x01\x82\x01\x86a\x1A\xC1V[\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\x81Ra\x1CS`\x02\x82\x01\x85a\x1A\xC1V[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x1D Wa\x1D a\x1ATV[P`\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`\x12`\x04R`$_\xFD[_\x82a\x1DbWa\x1Dba\x1D'V[P\x04\x90V[_\x82a\x1DuWa\x1Dua\x1D'V[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a\x14\xDBWa\x14\xDBa\x1ATV[`@\x81R_a\x1D\x9F`@\x83\x01\x85a\x16\xD4V[\x82\x81\x03` \x84\x01Ra\x1D\xB1\x81\x85a\x16\xD4V[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x1D\xCAW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xE0W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x1D\xF0W__\xFD[\x80Qa\x1D\xFEa\x16\x93\x82a\x16&V[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a\x1E\x12W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV\xFE\xA2dipfsX\"\x12 \xB3\xE9p2\xB7\x0E8\xAD\x1A\xBC\x87\xD2W\x17|\xDE\x02\x08\xEEU\x1D\x9B\xFC\x1A%\x85\x97}IF\xA3adsolcC\0\x08\x1C\x003`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa);8\x03\x80a);\x839\x81\x01`@\x81\x90Ra\0.\x91a\x03+V[\x82\x82\x82\x82\x82\x82a\0?\x83Q`P\x14\x90V[a\0\x84W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x11`$\x82\x01RpBad genesis block`x\x1B`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\0\x8E\x84a\x01fV[\x90Pb\xFF\xFF\xFF\x82\x16\x15a\x01\tW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FPeriod start hash does not have `D\x82\x01R\x7Fwork. Hint: wrong byte order?\0\0\0`d\x82\x01R`\x84\x01a\0{V[_\x81\x81U`\x01\x82\x90U`\x02\x82\x90U\x81\x81R`\x04` R`@\x90 \x83\x90Ua\x012a\x07\xE0\x84a\x03\xFEV[a\x01<\x90\x84a\x04%V[_\x83\x81R`\x04` R`@\x90 Ua\x01S\x84a\x02&V[`\x05UPa\x05\xBD\x98PPPPPPPPPV[_`\x02\x80\x83`@Qa\x01x\x91\x90a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\x93W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x04NV[`@Q` \x01a\x01\xC8\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x01\xE2\x91a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\xFDW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02 \x91\x90a\x04NV[\x92\x91PPV[_a\x02 a\x023\x83a\x028V[a\x02CV[_a\x02 \x82\x82a\x02SV[_a\x02 a\xFF\xFF`\xD0\x1B\x83a\x02\xF7V[_\x80a\x02ja\x02c\x84`Ha\x04eV[\x85\x90a\x03\tV[`\xE8\x1C\x90P_\x84a\x02|\x85`Ka\x04eV[\x81Q\x81\x10a\x02\x8CWa\x02\x8Ca\x04xV[\x01` \x01Q`\xF8\x1C\x90P_a\x02\xBE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x02\xD1`\x03\x84a\x04\x8CV[`\xFF\x16\x90Pa\x02\xE2\x81a\x01\0a\x05\x88V[a\x02\xEC\x90\x83a\x05\x93V[\x97\x96PPPPPPPV[_a\x03\x02\x82\x84a\x05\xAAV[\x93\x92PPPV[_a\x03\x02\x83\x83\x01` \x01Q\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x03=W__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03RW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03bW__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03{Wa\x03{a\x03\x17V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x03\xA9Wa\x03\xA9a\x03\x17V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x03\xC0W__\xFD[\x81` \x84\x01` \x83\x01^_` \x92\x82\x01\x83\x01R\x90\x86\x01Q`@\x90\x96\x01Q\x90\x97\x95\x96P\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x04\x0CWa\x04\x0Ca\x03\xEAV[P\x06\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x04^W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02 Wa\x02 a\x04\x11V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[`\x01\x81[`\x01\x84\x11\x15a\x04\xE0W\x80\x85\x04\x81\x11\x15a\x04\xC4Wa\x04\xC4a\x04\x11V[`\x01\x84\x16\x15a\x04\xD2W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x04\xA9V[\x93P\x93\x91PPV[_\x82a\x04\xF6WP`\x01a\x02 V[\x81a\x05\x02WP_a\x02 V[\x81`\x01\x81\x14a\x05\x18W`\x02\x81\x14a\x05\"Wa\x05>V[`\x01\x91PPa\x02 V[`\xFF\x84\x11\x15a\x053Wa\x053a\x04\x11V[PP`\x01\x82\x1Ba\x02 V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x05aWP\x81\x81\na\x02 V[a\x05m_\x19\x84\x84a\x04\xA5V[\x80_\x19\x04\x82\x11\x15a\x05\x80Wa\x05\x80a\x04\x11V[\x02\x93\x92PPPV[_a\x03\x02\x83\x83a\x04\xE8V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x02 Wa\x02 a\x04\x11V[_\x82a\x05\xB8Wa\x05\xB8a\x03\xEAV[P\x04\x90V[a#q\x80a\x05\xCA_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\xADW\x80c\xB9\x85b\x1A\x11a\0}W\x80c\xE3\xD8\xD8\xD8\x11a\0cW\x80c\xE3\xD8\xD8\xD8\x14a\x02\"W\x80c\xE4q\xE7,\x14a\x02)W\x80c\xF5\x8D\xB0o\x14a\x02=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x13\x91\x90a!WV[`@Q` \x01a\x0C%\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\x90\x82\x90Ra\x0C]\x91a!AV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0CxW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x07\x91\x90a!WV[_\x83\x85\x14\x80\x15a\x0C\xAAWP\x82\x85\x14[\x15a\x0C\xB7WP`\x01a\x04\xF1V[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x0C\xFFW\x89\x83\x14a\x0C\xDEW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x0C\xF7W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x0C\xBDV[P\x82\x84\x03a\r\x13W_\x94PPPPPa\x04\xF1V[\x80\x82\x14a\r&W_\x94PPPPPa\x04\xF1V[P`\x01\x98\x97PPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\rYW_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\r9V[P\x80a\x05\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x80\x82\x81[a\r\xB8`\x04`\x01a!\x9BV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0E\x0CW_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\r\xF1W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0E\x04V[a\r\xFB\x81\x84a!\xB7V[\x95\x94PPPPPV[`\x01\x01a\r\xACV[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_`P\x82Qa\x0B~\x91\x90a!.V[__a\x0Eo\x85a\x0B\xC3V[\x90P_a\x0E{\x82a\r\xA7V[\x90P_a\x0E\x87\x86a\x19\xE6V[\x90P\x84\x80a\x0E\x9CWP\x80a\x0E\x9A\x88a\x19\xE6V[\x14[a\x0F\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x03.V[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x12\x0EWa\x0F(`P\x82a!\xCAV[a\x0F3\x90`\x01a!\xB7V[a\x0F=\x90\x87a!\xB7V[\x93Pa\x0FK\x8A\x82`Pa\x19\xF1V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x11!W\x84a\x10\xA1\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x10\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x11\n`\x04\x85a!.V[_\x03a\x11!W_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x11,\x8B\x83a\x1A\x16V[\x14a\x11yW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[\x86a\x11\x84\x8B\x83a\x1A\xAFV[\x14a\x11\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x03.V[\x82\x96P`P\x81a\x12\x07\x91\x90a!\xB7V[\x90Pa\x0F\x15V[P\x81a\x12\x19\x8Ba\x0B\xC3V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x12\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x12\xD4\x84a\x0B\xC3V[\x90P_a\x12\xE0\x86a\x0B\xC3V[\x90P`\x01T\x81\x14a\x133W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x03.V[_\x82\x81R`\x03` R`@\x90 Ta\x13\x8DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x13\x9B\x87`\x01T\x84\x87a\x0C\x9BV[a\x14\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x03.V[\x81a\x14\x19\x88\x88\x88a\x17\x80V[\x14a\x14\x8CW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[`\x01\x82\x90U`\x02\x87\x90U_a\x14\xA0\x86a\x1A\xC7V[\x90P`\x05T\x81\x14a\x14\xB1W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x15\x01a\x14\xFC\x86a\x0B\xC3V[a\r\xA7V[\x90P_a\x15\x10a\x14\xFC\x86a\x0B\xC3V[\x90Pa\x15\x1Ea\x07\xE0\x82a!.V[a\x07\xDF\x14a\x15\x94W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x03.V[a\x15\xA0\x82a\x07\xDFa!\xB7V[\x81\x14a\x16\x14W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x03.V[a\x16\x1D\x85a\x1A\xC7V[a\x16&\x87a\x1A\xC7V[\x14a\x16\x99W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x03.V[_a\x16\xA3\x85a\x19\xE6V[\x90P_a\x16\xD5a\x16\xB2\x89a\x19\xE6V[a\x16\xBB\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x16\xCA\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x1B\x0CV[\x90P\x81\x81\x83\x16\x14a\x17(W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_a\x172\x89a\x1A\xC7V[\x90P\x80`\x06T\x14\x15\x80\x15a\x17\\WPa\x07\xE0a\x17O`\x01Ta\r\xA7V[a\x17Y\x91\x90a!\xDDV[\x84\x11[\x15a\x17gW`\x06\x81\x90U[a\x17s\x88\x88`\x01a\x0EdV[\x99\x98PPPPPPPPPV[__a\x17\x8B\x85a\r\xA7V[\x90P_a\x17\x9Aa\x14\xFC\x86a\x0B\xC3V[\x90P_a\x17\xA9a\x14\xFC\x86a\x0B\xC3V[\x90P\x82\x82\x10\x15\x80\x15a\x17\xBBWP\x82\x81\x10\x15[a\x18-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x18:a\x07\xE0\x85a!.V[a\x18F\x85a\x07\xE0a!\xB7V[a\x18P\x91\x90a!\xDDV[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x18bWP\x80[\x15a\x18}Wa\x18p\x89a\x0B\xC3V[\x96PPPPPPPa\n\xA3V[\x81\x80\x15a\x18\x88WP\x80\x15[\x15a\x18\x96Wa\x18p\x88a\x0B\xC3V[\x81\x80\x15a\x18\xA0WP\x80[\x15a\x18\xC4W\x83\x85\x10\x15a\x18\xBBWa\x18\xB6\x88a\x0B\xC3V[a\x18pV[a\x18p\x89a\x0B\xC3V[a\x18\xCD\x88a\x1A\xC7V[a\x18\xD9a\x07\xE0\x86a!.V[a\x18\xE3\x91\x90a!\xF0V[a\x18\xEC\x8Aa\x1A\xC7V[a\x18\xF8a\x07\xE0\x88a!.V[a\x19\x02\x91\x90a!\xF0V[\x10\x15a\x18\xBBWa\x18p\x88a\x0B\xC3V[`\x07T_\x90`\xFF\x16\x15a\x19/WP`\x07Ta\x01\0\x90\x04`\xFF\x16a\n\xA3V[a\x19:\x84\x84\x84a\x1B\x94V[\x90Pa\n\xA3V[_` \x84Qa\x19P\x91\x90a!.V[\x15a\x19\\WP_a\x04\xF1V[\x83Q_\x03a\x19kWP_a\x04\xF1V[\x81\x85_[\x86Q\x81\x10\x15a\x19\xD9Wa\x19\x83`\x02\x84a!.V[`\x01\x03a\x19\xA7Wa\x19\xA0a\x19\x9A\x88\x83\x01` \x01Q\x90V[\x83a\x1B\xD5V[\x91Pa\x19\xC0V[a\x19\xBD\x82a\x19\xB8\x89\x84\x01` \x01Q\x90V[a\x1B\xD5V[\x91P[`\x01\x92\x90\x92\x1C\x91a\x19\xD2` \x82a!\xB7V[\x90Pa\x19oV[P\x90\x93\x14\x95\x94PPPPPV[_a\x05\x07\x82_a\x1A\x16V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x1A-a\x1A&\x84`Ha!\xB7V[\x85\x90a\x1B\xE0V[`\xE8\x1C\x90P_\x84a\x1A?\x85`Ka!\xB7V[\x81Q\x81\x10a\x1AOWa\x1AOa\"\x07V[\x01` \x01Q`\xF8\x1C\x90P_a\x1A\x81\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1A\x94`\x03\x84a\"4V[`\xFF\x16\x90Pa\x1A\xA5\x81a\x01\0a#0V[a\x08-\x90\x83a!\xF0V[_a\x05\x04a\x1A\xBE\x83`\x04a!\xB7V[\x84\x01` \x01Q\x90V[_a\x05\x07a\x1A\xD4\x83a\x19\xE6V[a\x1B\xEEV[_a\x05\x07a\x1A\xE6\x83a\x1C\x15V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1B\x18\x83\x85a\x1C!V[\x90Pa\x1B(b\x12u\0`\x04a\x1C|V[\x81\x10\x15a\x1B@Wa\x1B=b\x12u\0`\x04a\x1C|V[\x90P[a\x1BNb\x12u\0`\x04a\x1C\x87V[\x81\x11\x15a\x1BfWa\x1Bcb\x12u\0`\x04a\x1C\x87V[\x90P[_a\x1B~\x82a\x1Bx\x88b\x01\0\0a\x1C|V[\x90a\x1C\x87V[\x90Pa\n\x8Ab\x01\0\0a\x1Bx\x83b\x12u\0a\x1C|V[_\x82\x81[\x83\x81\x10\x15a\x1B\xCAW\x85\x82\x03a\x1B\xB2W`\x01\x92PPPa\n\xA3V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x1B\x98V[P_\x95\x94PPPPPV[_a\x05\x04\x83\x83a\x1C\xFAV[_a\x05\x04\x83\x83\x01` \x01Q\x90V[_a\x05\x07{\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\x83a\x1C|V[_a\x05\x07\x82`Da\x1B\xE0V[_\x82\x82\x11\x15a\x1CrW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x05\x04\x82\x84a!\xDDV[_a\x05\x04\x82\x84a!\xCAV[_\x82_\x03a\x1C\x96WP_a\x05\x07V[a\x1C\xA0\x82\x84a!\xF0V[\x90P\x81a\x1C\xAD\x84\x83a!\xCAV[\x14a\x05\x07W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x03.V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1D1W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DHW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1D_W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1DvW__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1D\x91W__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xA7W__\xFD[a\x1D\xB3\x8A\x82\x8B\x01a\x1D!V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xD2W__\xFD[a\x1D\xDE\x8A\x82\x8B\x01a\x1D!V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1D\xFE`\x80\x89\x01a\x1DfV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[____`\x80\x85\x87\x03\x12\x15a\x1E\x1FW__\xFD[PP\x825\x94` \x84\x015\x94P`@\x84\x015\x93``\x015\x92P\x90PV[__`@\x83\x85\x03\x12\x15a\x1ELW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1EkW__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1E\x85W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x9BW__\xFD[a\x1E\xA7\x87\x82\x88\x01a\x1D!V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\xC6W__\xFD[a\x1E\xD2\x87\x82\x88\x01a\x1D!V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1E\xF3W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x10W__\xFD[a\x1F\x1C\x89\x82\x8A\x01a\x1D!V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F;W__\xFD[a\x1FG\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1FtW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x8AW__\xFD[a\x1F\x96\x89\x82\x8A\x01a\x1D!V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xB5W__\xFD[a\x1F\xC1\x89\x82\x8A\x01a\x1D!V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xE0W__\xFD[a\x1F\xEC\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_____``\x86\x88\x03\x12\x15a \x12W__\xFD[\x855\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a /W__\xFD[a ;\x88\x82\x89\x01a\x1D!V[\x90\x95P\x93PP`@\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a ZW__\xFD[a f\x88\x82\x89\x01a\x1D!V[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[___``\x84\x86\x03\x12\x15a \x89W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a \xB1W__\xFD[\x825\x91Pa \xC1` \x84\x01a\x1DfV[\x90P\x92P\x92\x90PV[\x805\x80\x15\x15\x81\x14a\x1DvW__\xFD[__`@\x83\x85\x03\x12\x15a \xEAW__\xFD[a \xF3\x83a \xCAV[\x91Pa \xC1` \x84\x01a \xCAV[\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!^<#\x11a\x01\x02W\x80cD\xBA\xDB\xB6\x11a\0\xE8W\x80cD\xBA\xDB\xB6\x14a\x01\xB6W\x80cf\xD9\xA9\xA0\x14a\x01\xD6W\x80c\x85\"l\x81\x14a\x01\xEBW__\xFD[\x80c>^<#\x14a\x01\xA6W\x80c?r\x86\xF4\x14a\x01\xAEW__\xFD[\x80c\x08\x13\x85*\x14a\x013W\x80c\x1C\r\xA8\x1F\x14a\x01\\W\x80c\x1E\xD7\x83\x1C\x14a\x01|W\x80c*\xDE8\x80\x14a\x01\x91W[__\xFD[a\x01Fa\x01A6`\x04a\x16MV[a\x02wV[`@Qa\x01S\x91\x90a\x17\x02V[`@Q\x80\x91\x03\x90\xF3[a\x01oa\x01j6`\x04a\x16MV[a\x02\xC2V[`@Qa\x01S\x91\x90a\x17eV[a\x01\x84a\x034V[`@Qa\x01S\x91\x90a\x17wV[a\x01\x99a\x03\xA1V[`@Qa\x01S\x91\x90a\x18)V[a\x01\x84a\x04\xEAV[a\x01\x84a\x05UV[a\x01\xC9a\x01\xC46`\x04a\x16MV[a\x05\xC0V[`@Qa\x01S\x91\x90a\x18\xADV[a\x01\xDEa\x06\x03V[`@Qa\x01S\x91\x90a\x19@V[a\x01\xF3a\x07|V[`@Qa\x01S\x91\x90a\x19\xBEV[a\x02\x08a\x08GV[`@Qa\x01S\x91\x90a\x19\xD0V[a\x02\x08a\tJV[a\x01\xF3a\nMV[a\x02-a\x0B\x18V[`@Q\x90\x15\x15\x81R` \x01a\x01SV[a\x02Ea\x0B\xE8V[\0[a\x01\x84a\r1V[a\x02Ea\r\x9CV[`\x1FTa\x02-\x90`\xFF\x16\x81V[a\x01\xC9a\x02r6`\x04a\x16MV[a\x0ENV[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x0E\x91V[\x94\x93PPPPV[``_a\x02\xD0\x85\x85\x85a\x02wV[\x90P_[a\x02\xDE\x85\x85a\x1A\x81V[\x81\x10\x15a\x03+W\x82\x82\x82\x81Q\x81\x10a\x02\xF8Wa\x02\xF8a\x1A\x94V[` \x02` \x01\x01Q`@Q` \x01a\x03\x11\x92\x91\x90a\x1A\xD8V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x02\xD4V[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\xCAW\x83\x82\x90_R` _ \x01\x80Ta\x04?\x90a\x1A\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x04k\x90a\x1A\xECV[\x80\x15a\x04\xB6W\x80`\x1F\x10a\x04\x8DWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x04\xB6V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x04\x99W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x04\"V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x03\xC4V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x0F\xF2V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x06V\x90a\x1A\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06\x82\x90a\x1A\xECV[\x80\x15a\x06\xCDW\x80`\x1F\x10a\x06\xA4Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x06\xCDV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x06\xB0W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07dW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x07\x11W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x06&V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x01\x80Ta\x07\xBC\x90a\x1A\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07\xE8\x90a\x1A\xECV[\x80\x15a\x083W\x80`\x1F\x10a\x08\nWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x083V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x08\x16W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x07\x9FV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\t2W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x08\xDFW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x08jV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\n5W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\t\xE2W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\tmV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x01\x80Ta\n\x8D\x90a\x1A\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n\xB9\x90a\x1A\xECV[\x80\x15a\x0B\x04W\x80`\x1F\x10a\n\xDBWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\x04V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\n\xE7W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\npV[`\x08T_\x90`\xFF\x16\x15a\x0B/WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0B\xBDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\xE1\x91\x90a\x1B=V[\x14\x15\x90P\x90V[a\x0C\xAF`\x1F`\x01\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\xB2[\x9B\0`$T`%`!`\x03\x81T\x81\x10a\x0CBWa\x0CBa\x1A\x94V[\x90_R` _ \x01`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0Ch\x93\x92\x91\x90a\x1C)V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0C\x83W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\xA7\x91\x90a\x1B=V[`&Ta\x11@V[a\r/`\x1F`\x01\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\xB2[\x9B\0`$T`!`\x03\x81T\x81\x10a\r\x07Wa\r\x07a\x1A\x94V[\x90_R` _ \x01`%`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0Ch\x93\x92\x91\x90a\x1C)V[V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[a\r\xF6`\x1F`\x01\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\xB2[\x9B\0`$T`%`\"`\x03\x81T\x81\x10a\x0CBWa\x0CBa\x1A\x94V[a\r/`\x1F`\x01\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\xB2[\x9B\0`$T`\"`\x03\x81T\x81\x10a\r\x07Wa\r\x07a\x1A\x94V[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x11\xC3V[``a\x0E\x9D\x84\x84a\x1A\x81V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0E\xB5Wa\x0E\xB5a\x15\xC8V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0E\xE8W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x0E\xD3W\x90P[P\x90P\x83[\x83\x81\x10\x15a\x0F\xE9Wa\x0F\xBB\x86a\x0F\x02\x83a\x13\x11V[\x85`@Q` \x01a\x0F\x15\x93\x92\x91\x90a\x1C]V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x0F1\x90a\x1A\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F]\x90a\x1A\xECV[\x80\x15a\x0F\xA8W\x80`\x1F\x10a\x0F\x7FWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F\xA8V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\x8BW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x14B\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x0F\xC6\x87\x84a\x1A\x81V[\x81Q\x81\x10a\x0F\xD6Wa\x0F\xD6a\x1A\x94V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x0E\xEDV[P\x94\x93PPPPV[``a\x0F\xFE\x84\x84a\x1A\x81V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10\x16Wa\x10\x16a\x15\xC8V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x10?W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x0F\xE9Wa\x11\x12\x86a\x10Y\x83a\x13\x11V[\x85`@Q` \x01a\x10l\x93\x92\x91\x90a\x1C]V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x10\x88\x90a\x1A\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x10\xB4\x90a\x1A\xECV[\x80\x15a\x10\xFFW\x80`\x1F\x10a\x10\xD6Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x10\xFFV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x10\xE2W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x14\xE1\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x11\x1D\x87\x84a\x1A\x81V[\x81Q\x81\x10a\x11-Wa\x11-a\x1A\x94V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x10DV[`@Q\x7F|\x84\xC6\x9B\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c|\x84\xC6\x9B\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x11\xA9W__\xFD[PZ\xFA\x15\x80\x15a\x11\xBBW=__>=_\xFD[PPPPPPV[``a\x11\xCF\x84\x84a\x1A\x81V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x11\xE7Wa\x11\xE7a\x15\xC8V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x12\x10W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x0F\xE9Wa\x12\xE3\x86a\x12*\x83a\x13\x11V[\x85`@Q` \x01a\x12=\x93\x92\x91\x90a\x1C]V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x12Y\x90a\x1A\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x12\x85\x90a\x1A\xECV[\x80\x15a\x12\xD0W\x80`\x1F\x10a\x12\xA7Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x12\xD0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x12\xB3W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x15t\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x12\xEE\x87\x84a\x1A\x81V[\x81Q\x81\x10a\x12\xFEWa\x12\xFEa\x1A\x94V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x12\x15V[``\x81_\x03a\x13SWPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x13|W\x80a\x13f\x81a\x1C\xF0V[\x91Pa\x13u\x90P`\n\x83a\x1DTV[\x91Pa\x13VV[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x13\x96Wa\x13\x96a\x15\xC8V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x13\xC0W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x02\xBAWa\x13\xD5`\x01\x83a\x1A\x81V[\x91Pa\x13\xE2`\n\x86a\x1DgV[a\x13\xED\x90`0a\x1DzV[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x14\x02Wa\x14\x02a\x1A\x94V[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x14;`\n\x86a\x1DTV[\x94Pa\x13\xC4V[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a\x14\x97\x90\x86\x90\x86\x90`\x04\x01a\x1D\x8DV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x14\xB1W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x14\xD8\x91\x90\x81\x01\x90a\x1D\xBAV[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x155\x90\x86\x90\x86\x90`\x04\x01a\x1D\x8DV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x15PW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x14\xD8\x91\x90a\x1B=V[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x155\x90\x86\x90\x86\x90`\x04\x01a\x1D\x8DV[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x16\x1EWa\x16\x1Ea\x15\xC8V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x16?Wa\x16?a\x15\xC8V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x16_W__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16uW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x16\x85W__\xFD[\x805a\x16\x98a\x16\x93\x82a\x16&V[a\x15\xF5V[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x16\xACW__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x17YW`?\x19\x87\x86\x03\x01\x84Ra\x17D\x85\x83Qa\x16\xD4V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x17(V[P\x92\x96\x95PPPPPPV[` \x81R_a\x14\xD8` \x83\x01\x84a\x16\xD4V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x17\xC4W\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\x17\x90V[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x18\x1DW`\x1F\x19\x85\x84\x03\x01\x88Ra\x18\x07\x83\x83Qa\x16\xD4V[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x17\xEBV[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x17YW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x18\x97`@\x87\x01\x82a\x17\xCFV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x18OV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x17\xC4W\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x18\xC6V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x196W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x18\xF6V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x17YW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x19\x8C`@\x88\x01\x82a\x16\xD4V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x19\xA7\x81\x83a\x18\xE4V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x19fV[` \x81R_a\x14\xD8` \x83\x01\x84a\x17\xCFV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x17YW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1A>`@\x87\x01\x82a\x18\xE4V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x19\xF6V[\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\x14\xDBWa\x14\xDBa\x1ATV[\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x02\xBAa\x1A\xE6\x83\x86a\x1A\xC1V[\x84a\x1A\xC1V[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1B\0W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x1B7W\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x1BMW__\xFD[PQ\x91\x90PV[\x80T_\x90`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1BlW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x1B\xA3W\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[\x81\x86R` \x86\x01\x81\x80\x15a\x1B\xBEW`\x01\x81\x14a\x1B\xF2Wa\x1C\x1EV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x85\x16\x82R\x83\x15\x15`\x05\x1B\x82\x01\x95Pa\x1C\x1EV[_\x87\x81R` \x90 _[\x85\x81\x10\x15a\x1C\x18W\x81T\x84\x82\x01R`\x01\x90\x91\x01\x90` \x01a\x1B\xFCV[\x83\x01\x96PP[PPPPP\x92\x91PPV[\x83\x81R``` \x82\x01R_a\x1CA``\x83\x01\x85a\x1BTV[\x82\x81\x03`@\x84\x01Ra\x1CS\x81\x85a\x1BTV[\x96\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\x81R_a\x1C\x8E`\x01\x83\x01\x86a\x1A\xC1V[\x7F[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x1C\xBE`\x01\x82\x01\x86a\x1A\xC1V[\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\x81Ra\x1CS`\x02\x82\x01\x85a\x1A\xC1V[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x1D Wa\x1D a\x1ATV[P`\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`\x12`\x04R`$_\xFD[_\x82a\x1DbWa\x1Dba\x1D'V[P\x04\x90V[_\x82a\x1DuWa\x1Dua\x1D'V[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a\x14\xDBWa\x14\xDBa\x1ATV[`@\x81R_a\x1D\x9F`@\x83\x01\x85a\x16\xD4V[\x82\x81\x03` \x84\x01Ra\x1D\xB1\x81\x85a\x16\xD4V[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x1D\xCAW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xE0W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x1D\xF0W__\xFD[\x80Qa\x1D\xFEa\x16\x93\x82a\x16&V[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a\x1E\x12W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV\xFE\xA2dipfsX\"\x12 \xB3\xE9p2\xB7\x0E8\xAD\x1A\xBC\x87\xD2W\x17|\xDE\x02\x08\xEEU\x1D\x9B\xFC\x1A%\x85\x97}IF\xA3adsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. -```solidity -event log(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolConstructor for constructorCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getBlockHeights(string,uint256,uint256)` and selector `0xfad06b8f`. -```solidity -function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getBlockHeightsCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getBlockHeights(string,uint256,uint256)`](getBlockHeightsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getBlockHeightsReturn { - #[allow(missing_docs)] - pub elements: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getBlockHeightsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - #[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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getBlockHeightsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getBlockHeightsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getBlockHeights(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [250u8, 208u8, 107u8, 143u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getDigestLes(string,uint256,uint256)` and selector `0x44badbb6`. -```solidity -function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getDigestLesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getDigestLes(string,uint256,uint256)`](getDigestLesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getDigestLesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getDigestLesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getDigestLesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getDigestLesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array< - alloy::sol_types::sol_data::FixedBytes<32>, - >, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getDigestLes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [68u8, 186u8, 219u8, 182u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaderHexes(string,uint256,uint256)` and selector `0x0813852a`. -```solidity -function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaderHexes(string,uint256,uint256)`](getHeaderHexesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeaderHexesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getHeaderHexesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getHeaderHexesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Bytes, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaderHexes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [8u8, 19u8, 133u8, 42u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaders(string,uint256,uint256)` and selector `0x1c0da81f`. -```solidity -function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaders(string,uint256,uint256)`](getHeadersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersReturn { - #[allow(missing_docs)] - pub headers: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersReturn) -> Self { - (value.headers,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { headers: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getHeadersCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Bytes; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaders(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [28u8, 13u8, 168u8, 31u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testHandlingDescendantsAtDifferentDifficultyPeriod()` and selector `0xbbf93952`. -```solidity -function testHandlingDescendantsAtDifferentDifficultyPeriod() external view; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testHandlingDescendantsAtDifferentDifficultyPeriodCall; - ///Container type for the return parameters of the [`testHandlingDescendantsAtDifferentDifficultyPeriod()`](testHandlingDescendantsAtDifferentDifficultyPeriodCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testHandlingDescendantsAtDifferentDifficultyPeriodReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From< - testHandlingDescendantsAtDifferentDifficultyPeriodCall, - > for UnderlyingRustTuple<'_> { - fn from( - value: testHandlingDescendantsAtDifferentDifficultyPeriodCall, - ) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testHandlingDescendantsAtDifferentDifficultyPeriodCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From< - testHandlingDescendantsAtDifferentDifficultyPeriodReturn, - > for UnderlyingRustTuple<'_> { - fn from( - value: testHandlingDescendantsAtDifferentDifficultyPeriodReturn, - ) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testHandlingDescendantsAtDifferentDifficultyPeriodReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testHandlingDescendantsAtDifferentDifficultyPeriodReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall - for testHandlingDescendantsAtDifferentDifficultyPeriodCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testHandlingDescendantsAtDifferentDifficultyPeriodReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testHandlingDescendantsAtDifferentDifficultyPeriod()"; - const SELECTOR: [u8; 4] = [187u8, 249u8, 57u8, 82u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testHandlingDescendantsAtDifferentDifficultyPeriodReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriod()` and selector `0xf11fa172`. -```solidity -function testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriod() external view; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriodCall; - ///Container type for the return parameters of the [`testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriod()`](testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriodCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriodReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From< - testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriodCall, - > for UnderlyingRustTuple<'_> { - fn from( - value: testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriodCall, - ) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriodCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From< - testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriodReturn, - > for UnderlyingRustTuple<'_> { - fn from( - value: testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriodReturn, - ) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriodReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriodReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall - for testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriodCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriodReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriod()"; - const SELECTOR: [u8; 4] = [241u8, 31u8, 161u8, 114u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriodReturn::_tokenize( - ret, - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`FullRelayHeaviestFromAncestorWithRetargetTest`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum FullRelayHeaviestFromAncestorWithRetargetTestCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - getBlockHeights(getBlockHeightsCall), - #[allow(missing_docs)] - getDigestLes(getDigestLesCall), - #[allow(missing_docs)] - getHeaderHexes(getHeaderHexesCall), - #[allow(missing_docs)] - getHeaders(getHeadersCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - testHandlingDescendantsAtDifferentDifficultyPeriod( - testHandlingDescendantsAtDifferentDifficultyPeriodCall, - ), - #[allow(missing_docs)] - testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriod( - testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriodCall, - ), - } - #[automatically_derived] - impl FullRelayHeaviestFromAncestorWithRetargetTestCalls { - /// 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, 19u8, 133u8, 42u8], - [28u8, 13u8, 168u8, 31u8], - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [68u8, 186u8, 219u8, 182u8], - [102u8, 217u8, 169u8, 160u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [187u8, 249u8, 57u8, 82u8], - [226u8, 12u8, 159u8, 113u8], - [241u8, 31u8, 161u8, 114u8], - [250u8, 118u8, 38u8, 212u8], - [250u8, 208u8, 107u8, 143u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface - for FullRelayHeaviestFromAncestorWithRetargetTestCalls { - const NAME: &'static str = "FullRelayHeaviestFromAncestorWithRetargetTestCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 18usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::getBlockHeights(_) => { - ::SELECTOR - } - Self::getDigestLes(_) => { - ::SELECTOR - } - Self::getHeaderHexes(_) => { - ::SELECTOR - } - Self::getHeaders(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::testHandlingDescendantsAtDifferentDifficultyPeriod(_) => { - ::SELECTOR - } - Self::testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriod( - _, - ) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - >] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::getHeaderHexes, - ) - } - getHeaderHexes - }, - { - fn getHeaders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::getHeaders, - ) - } - getHeaders - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::excludeSenders, - ) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::targetInterfaces, - ) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::targetSenders, - ) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::targetContracts, - ) - } - targetContracts - }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::getDigestLes, - ) - } - getDigestLes - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::targetArtifacts, - ) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::targetSelectors, - ) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::excludeSelectors, - ) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::excludeArtifacts, - ) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw(data) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::failed, - ) - } - failed - }, - { - fn testHandlingDescendantsAtDifferentDifficultyPeriod( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::testHandlingDescendantsAtDifferentDifficultyPeriod, - ) - } - testHandlingDescendantsAtDifferentDifficultyPeriod - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::excludeContracts, - ) - } - excludeContracts - }, - { - fn testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriod( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriod, - ) - } - testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriod - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw(data) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::IS_TEST, - ) - } - IS_TEST - }, - { - fn getBlockHeights( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::getBlockHeights, - ) - } - getBlockHeights - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - >] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::getHeaderHexes, - ) - } - getHeaderHexes - }, - { - fn getHeaders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::getHeaders, - ) - } - getHeaders - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::excludeSenders, - ) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::targetInterfaces, - ) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::targetSenders, - ) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::targetContracts, - ) - } - targetContracts - }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::getDigestLes, - ) - } - getDigestLes - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::targetArtifacts, - ) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::targetSelectors, - ) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::excludeSelectors, - ) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::excludeArtifacts, - ) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::failed, - ) - } - failed - }, - { - fn testHandlingDescendantsAtDifferentDifficultyPeriod( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::testHandlingDescendantsAtDifferentDifficultyPeriod, - ) - } - testHandlingDescendantsAtDifferentDifficultyPeriod - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::excludeContracts, - ) - } - excludeContracts - }, - { - fn testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriod( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriod, - ) - } - testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriod - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::IS_TEST, - ) - } - IS_TEST - }, - { - fn getBlockHeights( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorWithRetargetTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayHeaviestFromAncestorWithRetargetTestCalls::getBlockHeights, - ) - } - getBlockHeights - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::getBlockHeights(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getDigestLes(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getHeaders(inner) => { - ::abi_encoded_size(inner) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testHandlingDescendantsAtDifferentDifficultyPeriod(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriod( - inner, - ) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::getBlockHeights(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getDigestLes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testHandlingDescendantsAtDifferentDifficultyPeriod(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriod( - inner, - ) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`FullRelayHeaviestFromAncestorWithRetargetTest`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum FullRelayHeaviestFromAncestorWithRetargetTestEvents { - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl FullRelayHeaviestFromAncestorWithRetargetTestEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface - for FullRelayHeaviestFromAncestorWithRetargetTestEvents { - const NAME: &'static str = "FullRelayHeaviestFromAncestorWithRetargetTestEvents"; - const COUNT: usize = 22usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 FullRelayHeaviestFromAncestorWithRetargetTestEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`FullRelayHeaviestFromAncestorWithRetargetTest`](self) contract instance. - -See the [wrapper's documentation](`FullRelayHeaviestFromAncestorWithRetargetTestInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> FullRelayHeaviestFromAncestorWithRetargetTestInstance { - FullRelayHeaviestFromAncestorWithRetargetTestInstance::< - 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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result< - FullRelayHeaviestFromAncestorWithRetargetTestInstance, - >, - > { - FullRelayHeaviestFromAncestorWithRetargetTestInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - FullRelayHeaviestFromAncestorWithRetargetTestInstance::< - P, - N, - >::deploy_builder(provider) - } - /**A [`FullRelayHeaviestFromAncestorWithRetargetTest`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`FullRelayHeaviestFromAncestorWithRetargetTest`](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 FullRelayHeaviestFromAncestorWithRetargetTestInstance< - P, - N = alloy_contract::private::Ethereum, - > { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug - for FullRelayHeaviestFromAncestorWithRetargetTestInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("FullRelayHeaviestFromAncestorWithRetargetTestInstance") - .field(&self.address) - .finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayHeaviestFromAncestorWithRetargetTestInstance { - /**Creates a new wrapper around an on-chain [`FullRelayHeaviestFromAncestorWithRetargetTest`](self) contract instance. - -See the [wrapper's documentation](`FullRelayHeaviestFromAncestorWithRetargetTestInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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< - FullRelayHeaviestFromAncestorWithRetargetTestInstance, - > { - 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 { - 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, - > FullRelayHeaviestFromAncestorWithRetargetTestInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider( - self, - ) -> FullRelayHeaviestFromAncestorWithRetargetTestInstance { - FullRelayHeaviestFromAncestorWithRetargetTestInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayHeaviestFromAncestorWithRetargetTestInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`getBlockHeights`] function. - pub fn getBlockHeights( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getBlockHeightsCall, N> { - self.call_builder( - &getBlockHeightsCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getDigestLes`] function. - pub fn getDigestLes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getDigestLesCall, N> { - self.call_builder( - &getDigestLesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaderHexes`] function. - pub fn getHeaderHexes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeaderHexesCall, N> { - self.call_builder( - &getHeaderHexesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaders`] function. - pub fn getHeaders( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeadersCall, N> { - self.call_builder( - &getHeadersCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`testHandlingDescendantsAtDifferentDifficultyPeriod`] function. - pub fn testHandlingDescendantsAtDifferentDifficultyPeriod( - &self, - ) -> alloy_contract::SolCallBuilder< - &P, - testHandlingDescendantsAtDifferentDifficultyPeriodCall, - N, - > { - self.call_builder(&testHandlingDescendantsAtDifferentDifficultyPeriodCall) - } - ///Creates a new call builder for the [`testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriod`] function. - pub fn testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriod( - &self, - ) -> alloy_contract::SolCallBuilder< - &P, - testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriodCall, - N, - > { - self.call_builder( - &testHandlingDescendantsWhenBothAtDifferentNewDifficultyPeriodCall, - ) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayHeaviestFromAncestorWithRetargetTestInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/fullrelayismostancestortest.rs b/crates/bindings/src/fullrelayismostancestortest.rs deleted file mode 100644 index 101f4dcc4..000000000 --- a/crates/bindings/src/fullrelayismostancestortest.rs +++ /dev/null @@ -1,9113 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface FullRelayIsMostAncestorTest { - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - constructor(); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); - function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); - function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); - function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function testLeftAndRightAndAncestorSame() external view; - function testReturnsFalseIfLimitExceeded() external view; - function testReturnsFalseIfMoreRecentAncestorFound() external view; - function testReturnsTrueIfWithinLimit() external view; -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getBlockHeights", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getDigestLes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes32[]", - "internalType": "bytes32[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaderHexes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes[]", - "internalType": "bytes[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaders", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "headers", - "type": "bytes", - "internalType": "bytes" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testLeftAndRightAndAncestorSame", - "inputs": [], - "outputs": [], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testReturnsFalseIfLimitExceeded", - "inputs": [], - "outputs": [], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testReturnsFalseIfMoreRecentAncestorFound", - "inputs": [], - "outputs": [], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testReturnsTrueIfWithinLimit", - "inputs": [], - "outputs": [], - "stateMutability": "view" - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 FullRelayIsMostAncestorTest { - use super::*; - use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15a\0,W__\xFD[P`@Q\x80`@\x01`@R\x80`\x1C\x81R` \x01\x7FheadersReorgAndRetarget.json\0\0\0\0\x81RP`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k\x05\xCC\xEC\xAD\xCC\xAEm.e\xCD\x0C\xAF`\xA3\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x0F\x81R` \x01n\x0B\x99\xD9[\x99\\\xDA\\\xCB\x9A\x19ZY\xDA\x1D`\x8A\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x19\x81R` \x01\x7F.oldPeriodStart.digest_le\0\0\0\0\0\0\0\x81RP__Q` a]:_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x16c\xD90\xA0\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01/W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01V\x91\x90\x81\x01\x90a\x0E\xDBV[\x90P_\x81\x86`@Q` \x01a\x01l\x92\x91\x90a\x0F6V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Rc`\xF9\xBB\x11`\xE0\x1B\x82R\x91P_Q` a]:_9_Q\x90_R\x90c`\xF9\xBB\x11\x90a\x01\xAC\x90\x84\x90`\x04\x01a\x0F\xA8V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xC6W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01\xED\x91\x90\x81\x01\x90a\x0E\xDBV[` \x90a\x01\xFA\x90\x82a\x10>V[Pa\x02\x91\x85` \x80Ta\x02\x0C\x90a\x0F\xBAV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x028\x90a\x0F\xBAV[\x80\x15a\x02\x83W\x80`\x1F\x10a\x02ZWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02\x83V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02fW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x08\xA9\x91PPV[a\x03'\x85` \x80Ta\x02\xA2\x90a\x0F\xBAV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\xCE\x90a\x0F\xBAV[\x80\x15a\x03\x19W\x80`\x1F\x10a\x02\xF0Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\x19V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02\xFCW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\t(\x91PPV[a\x03\xBD\x85` \x80Ta\x038\x90a\x0F\xBAV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03d\x90a\x0F\xBAV[\x80\x15a\x03\xAFW\x80`\x1F\x10a\x03\x86Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xAFV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\x92W\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\t\x9B\x91PPV[`@Qa\x03\xC9\x90a\rBV[a\x03\xD5\x93\x92\x91\x90a\x10\xF8V[`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03\xEEW=__>=_\xFD[P`\x1F`\x01a\x01\0\n\x81T\x81`\x01`\x01`\xA0\x1B\x03\x02\x19\x16\x90\x83`\x01`\x01`\xA0\x1B\x03\x16\x02\x17\x90UPPPPPPPa\x04U`@Q\x80`@\x01`@R\x80`\x10\x81R` \x01o892\xA92\xBA0\xB93\xB2\xBA!\xB40\xB4\xB7`\x81\x1B\x81RP_`\x05a\t\xCF` \x1B` \x1CV[\x80Qa\x04i\x91`!\x91` \x90\x91\x01\x90a\rOV[P`@\x80Q\x80\x82\x01\x90\x91R`\x11\x81Rp87\xB9\xBA)2\xBA0\xB93\xB2\xBA!\xB40\xB4\xB7`y\x1B` \x82\x01Ra\x04\x9E\x90_`\x08a\n\x06V[\x80Qa\x04\xB2\x91`\"\x91` \x90\x91\x01\x90a\r\xA3V[P_a\x04\xEE`@Q\x80`@\x01`@R\x80`\x10\x81R` \x01o892\xA92\xBA0\xB93\xB2\xBA!\xB40\xB4\xB7`\x81\x1B\x81RP_`\x05a\n;` \x1B` \x1CV[\x90P_a\x05,`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01p87\xB9\xBA)2\xBA0\xB93\xB2\xBA!\xB40\xB4\xB7`y\x1B\x81RP_`\x08a\n;` \x1B` \x1CV[\x90P_a\x05p`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01p87\xB9\xBA)2\xBA0\xB93\xB2\xBA!\xB40\xB4\xB7`y\x1B\x81RP_`\x02`\x08a\x05k\x91\x90a\x110V[a\n;V[\x90Pa\x05\xAD`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01q\x05\xCD\xEEN\r\x0C-\xCB\xE6\x86f\xE6\x86\xE7\x05\xCD\x0C\xAF`s\x1B\x81RP` \x80Ta\x02\x0C\x90a\x0F\xBAV[`$\x90a\x05\xBA\x90\x82a\x10>V[Pa\x06\x01`@Q\x80`@\x01`@R\x80`\x18\x81R` \x01\x7F.orphan_437478.digest_le\0\0\0\0\0\0\0\0\x81RP` \x80Ta\x038\x90a\x0F\xBAV[`%U`@Q_\x90a\x06\x1A\x90\x83\x90`$\x90` \x01a\x11CV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90P_a\x06a`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k\x05\xCC\xEC\xAD\xCC\xAEm.e\xCD\x0C\xAF`\xA3\x1B\x81RP` \x80Ta\x02\x0C\x90a\x0F\xBAV[\x90Pa\x06\x9E`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01q.genesis.digest_le`p\x1B\x81RP` \x80Ta\x038\x90a\x0F\xBAV[`#\x81\x90UP_a\x06\xEB`@Q\x80`@\x01`@R\x80`\x13\x81R` \x01\x7F.oldPeriodStart.hex\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x80Ta\x02\x0C\x90a\x0F\xBAV[`\x1FT`@Qce\xDAA\xB9`\xE0\x1B\x81R\x91\x92Pa\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90ce\xDAA\xB9\x90a\x07#\x90\x85\x90\x8A\x90`\x04\x01a\x11\xC0V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x07?W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07c\x91\x90a\x11\xE4V[P`\x1FTa\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16c\x7F\xA67\xFC\x82`!a\x07\x89`\x01`\x05a\x110V[\x81T\x81\x10a\x07\x99Wa\x07\x99a\x12\nV[\x90_R` _ \x01\x88`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x07\xC0\x93\x92\x91\x90a\x12\x1EV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x07\xDCW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\0\x91\x90a\x11\xE4V[P`\x1FTa\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16c\x7F\xA67\xFC\x82`!a\x08&`\x01`\x05a\x110V[\x81T\x81\x10a\x086Wa\x086a\x12\nV[\x90_R` _ \x01\x86`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x08]\x93\x92\x91\x90a\x12\x1EV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x08yW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\x9D\x91\x90a\x11\xE4V[PPPPPPPa\x13\xA8V[`@Qc\x1F\xB2C}`\xE3\x1B\x81R``\x90_Q` a]:_9_Q\x90_R\x90c\xFD\x92\x1B\xE8\x90a\x08\xDE\x90\x86\x90\x86\x90`\x04\x01a\x11\xC0V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\xF8W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\t\x1F\x91\x90\x81\x01\x90a\x0E\xDBV[\x90P[\x92\x91PPV[`@QcV\xEE\xF1[`\xE1\x1B\x81R_\x90_Q` a]:_9_Q\x90_R\x90c\xAD\xDD\xE2\xB6\x90a\t\\\x90\x86\x90\x86\x90`\x04\x01a\x11\xC0V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\twW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\x1F\x91\x90a\x12\xCEV[`@Qc\x17w\xE5\x9D`\xE0\x1B\x81R_\x90_Q` a]:_9_Q\x90_R\x90c\x17w\xE5\x9D\x90a\t\\\x90\x86\x90\x86\x90`\x04\x01a\x11\xC0V[``a\t\xFE\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01b\r\x0C\xAF`\xEB\x1B\x81RPa\n\xAD` \x1B` \x1CV[\x94\x93PPPPV[``a\t\xFE\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01hdigest_le`\xB8\x1B\x81RPa\x0B\x83` \x1B` \x1CV[``_a\nI\x85\x85\x85a\t\xCFV[\x90P_[a\nW\x85\x85a\x110V[\x81\x10\x15a\n\xA4W\x82\x82\x82\x81Q\x81\x10a\nqWa\nqa\x12\nV[` \x02` \x01\x01Q`@Q` \x01a\n\x8A\x92\x91\x90a\x12\xE5V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\nMV[PP\x93\x92PPPV[``a\n\xB9\x84\x84a\x110V[`\x01`\x01`@\x1B\x03\x81\x11\x15a\n\xD0Wa\n\xD0a\x0ERV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0B\x03W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\n\xEEW\x90P[P\x90P\x83[\x83\x81\x10\x15a\x0BzWa\x0BL\x86a\x0B\x1D\x83a\x0CFV[\x85`@Q` \x01a\x0B0\x93\x92\x91\x90a\x12\xF9V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x02\x0C\x90a\x0F\xBAV[\x82a\x0BW\x87\x84a\x110V[\x81Q\x81\x10a\x0BgWa\x0Bga\x12\nV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x0B\x08V[P\x94\x93PPPPV[``a\x0B\x8F\x84\x84a\x110V[`\x01`\x01`@\x1B\x03\x81\x11\x15a\x0B\xA6Wa\x0B\xA6a\x0ERV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0B\xCFW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x0BzWa\x0C\x18\x86a\x0B\xE9\x83a\x0CFV[\x85`@Q` \x01a\x0B\xFC\x93\x92\x91\x90a\x12\xF9V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x038\x90a\x0F\xBAV[\x82a\x0C#\x87\x84a\x110V[\x81Q\x81\x10a\x0C3Wa\x0C3a\x12\nV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x0B\xD4V[``\x81_\x03a\x0ClWPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R`\x03`\xFC\x1B` \x82\x01R\x90V[\x81_[\x81\x15a\x0C\x95W\x80a\x0C\x7F\x81a\x13CV[\x91Pa\x0C\x8E\x90P`\n\x83a\x13oV[\x91Pa\x0CoV[_\x81`\x01`\x01`@\x1B\x03\x81\x11\x15a\x0C\xAEWa\x0C\xAEa\x0ERV[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x0C\xD8W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\t\xFEWa\x0C\xED`\x01\x83a\x110V[\x91Pa\x0C\xFA`\n\x86a\x13\x82V[a\r\x05\x90`0a\x13\x95V[`\xF8\x1B\x81\x83\x81Q\x81\x10a\r\x1AWa\r\x1Aa\x12\nV[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SPa\r;`\n\x86a\x13oV[\x94Pa\x0C\xDCV[a);\x80a3\xFF\x839\x01\x90V[\x82\x80T\x82\x82U\x90_R` _ \x90\x81\x01\x92\x82\x15a\r\x93W\x91` \x02\x82\x01[\x82\x81\x11\x15a\r\x93W\x82Q\x82\x90a\r\x83\x90\x82a\x10>V[P\x91` \x01\x91\x90`\x01\x01\x90a\rmV[Pa\r\x9F\x92\x91Pa\r\xE8V[P\x90V[\x82\x80T\x82\x82U\x90_R` _ \x90\x81\x01\x92\x82\x15a\r\xDCW\x91` \x02\x82\x01[\x82\x81\x11\x15a\r\xDCW\x82Q\x82U\x91` \x01\x91\x90`\x01\x01\x90a\r\xC1V[Pa\r\x9F\x92\x91Pa\x0E\x04V[\x80\x82\x11\x15a\r\x9FW_a\r\xFB\x82\x82a\x0E\x18V[P`\x01\x01a\r\xE8V[[\x80\x82\x11\x15a\r\x9FW_\x81U`\x01\x01a\x0E\x05V[P\x80Ta\x0E$\x90a\x0F\xBAV[_\x82U\x80`\x1F\x10a\x0E3WPPV[`\x1F\x01` \x90\x04\x90_R` _ \x90\x81\x01\x90a\x0EO\x91\x90a\x0E\x04V[PV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x80`\x01`\x01`@\x1B\x03\x84\x11\x15a\x0E\x7FWa\x0E\x7Fa\x0ERV[P`@Q`\x1F\x19`\x1F\x85\x01\x81\x16`?\x01\x16\x81\x01\x81\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17\x15a\x0E\xADWa\x0E\xADa\x0ERV[`@R\x83\x81R\x90P\x80\x82\x84\x01\x85\x10\x15a\x0E\xC4W__\xFD[\x83\x83` \x83\x01^_` \x85\x83\x01\x01RP\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x0E\xEBW__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x0F\0W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x0F\x10W__\xFD[a\t\xFE\x84\x82Q` \x84\x01a\x0EfV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x0FA\x82\x85a\x0F\x1FV[\x7F/test/fullRelay/testData/\0\0\0\0\0\0\0\x81Ra\x0Fq`\x19\x82\x01\x85a\x0F\x1FV[\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R_a\t\x1F` \x83\x01\x84a\x0FzV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x0F\xCEW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x0F\xECWcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\x109W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x10\x17WP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x106W_\x81U`\x01\x01a\x10#V[PP[PPPV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x10WWa\x10Wa\x0ERV[a\x10k\x81a\x10e\x84Ta\x0F\xBAV[\x84a\x0F\xF2V[` `\x1F\x82\x11`\x01\x81\x14a\x10\x9DW_\x83\x15a\x10\x86WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x106V[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x10\xCCW\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x10\xACV[P\x84\x82\x10\x15a\x10\xE9W\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[``\x81R_a\x11\n``\x83\x01\x86a\x0FzV[` \x83\x01\x94\x90\x94RP`@\x01R\x91\x90PV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\t\"Wa\t\"a\x11\x1CV[_a\x11N\x82\x85a\x0F\x1FV[_\x84Ta\x11Z\x81a\x0F\xBAV[`\x01\x82\x16\x80\x15a\x11qW`\x01\x81\x14a\x11\x86Wa\x11\xB3V[`\xFF\x19\x83\x16\x85R\x81\x15\x15\x82\x02\x85\x01\x93Pa\x11\xB3V[\x87_R` _ _[\x83\x81\x10\x15a\x11\xABW\x81T\x87\x82\x01R`\x01\x90\x91\x01\x90` \x01a\x11\x8FV[PP\x81\x85\x01\x93P[P\x91\x97\x96PPPPPPPV[`@\x81R_a\x11\xD2`@\x83\x01\x85a\x0FzV[\x82\x81\x03` \x84\x01Ra\x0Fq\x81\x85a\x0FzV[_` \x82\x84\x03\x12\x15a\x11\xF4W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x12\x03W__\xFD[\x93\x92PPPV[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[``\x81R_a\x120``\x83\x01\x86a\x0FzV[\x82\x81\x03` \x84\x01R_\x85Ta\x12D\x81a\x0F\xBAV[\x80\x84R`\x01\x82\x16\x80\x15a\x12^W`\x01\x81\x14a\x12zWa\x12\xAEV[`\xFF\x19\x83\x16` \x86\x01R` \x82\x15\x15`\x05\x1B\x86\x01\x01\x93Pa\x12\xAEV[\x88_R` _ _[\x83\x81\x10\x15a\x12\xA5W\x81T` \x82\x89\x01\x01R`\x01\x82\x01\x91P` \x81\x01\x90Pa\x12\x83V[\x86\x01` \x01\x94PP[PPP\x83\x81\x03`@\x85\x01Ra\x12\xC3\x81\x86a\x0FzV[\x97\x96PPPPPPPV[_` \x82\x84\x03\x12\x15a\x12\xDEW__\xFD[PQ\x91\x90PV[_a\t\xFEa\x12\xF3\x83\x86a\x0F\x1FV[\x84a\x0F\x1FV[`\x17`\xF9\x1B\x81R_a\x13\x0E`\x01\x83\x01\x86a\x0F\x1FV[`[`\xF8\x1B\x81Ra\x13\"`\x01\x82\x01\x86a\x0F\x1FV[\x90Pa.\x97`\xF1\x1B\x81Ra\x139`\x02\x82\x01\x85a\x0F\x1FV[\x96\x95PPPPPPV[_`\x01\x82\x01a\x13TWa\x13Ta\x11\x1CV[P`\x01\x01\x90V[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x13}Wa\x13}a\x13[V[P\x04\x90V[_\x82a\x13\x90Wa\x13\x90a\x13[V[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a\t\"Wa\t\"a\x11\x1CV[a J\x80a\x13\xB5_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01cW_5`\xE0\x1C\x80c{\xA3\xC1\x8C\x11a\0\xC7W\x80c\xBAAO\xA6\x11a\0}W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x02\x93W\x80c\xFAv&\xD4\x14a\x02\x9BW\x80c\xFA\xD0k\x8F\x14a\x02\xA8W__\xFD[\x80c\xBAAO\xA6\x14a\x02sW\x80c\xDE\xC5\xA9D\x14a\x02\x8BW__\xFD[\x80c\x91j\x17\xC6\x11a\0\xADW\x80c\x91j\x17\xC6\x14a\x02NW\x80c\xB0FO\xDC\x14a\x02cW\x80c\xB5P\x8A\xA9\x14a\x02kW__\xFD[\x80c{\xA3\xC1\x8C\x14a\x021W\x80c\x85\"l\x81\x14a\x029W__\xFD[\x80c?r\x86\xF4\x11a\x01\x1CW\x80cQq.'\x11a\x01\x02W\x80cQq.'\x14a\x02\nW\x80cf\xD9\xA9\xA0\x14a\x02\x14W\x80cz\x04\xC7\x15\x14a\x02)W__\xFD[\x80c?r\x86\xF4\x14a\x01\xE2W\x80cD\xBA\xDB\xB6\x14a\x01\xEAW__\xFD[\x80c\x1E\xD7\x83\x1C\x11a\x01LW\x80c\x1E\xD7\x83\x1C\x14a\x01\xB0W\x80c*\xDE8\x80\x14a\x01\xC5W\x80c>^<#\x14a\x01\xDAW__\xFD[\x80c\x08\x13\x85*\x14a\x01gW\x80c\x1C\r\xA8\x1F\x14a\x01\x90W[__\xFD[a\x01za\x01u6`\x04a\x19\x0BV[a\x02\xBBV[`@Qa\x01\x87\x91\x90a\x19\xC0V[`@Q\x80\x91\x03\x90\xF3[a\x01\xA3a\x01\x9E6`\x04a\x19\x0BV[a\x03\x06V[`@Qa\x01\x87\x91\x90a\x1A#V[a\x01\xB8a\x03xV[`@Qa\x01\x87\x91\x90a\x1A5V[a\x01\xCDa\x03\xE5V[`@Qa\x01\x87\x91\x90a\x1A\xE7V[a\x01\xB8a\x05.V[a\x01\xB8a\x05\x99V[a\x01\xFDa\x01\xF86`\x04a\x19\x0BV[a\x06\x04V[`@Qa\x01\x87\x91\x90a\x1BkV[a\x02\x12a\x06GV[\0[a\x02\x1Ca\x07YV[`@Qa\x01\x87\x91\x90a\x1B\xFEV[a\x02\x12a\x08\xD2V[a\x02\x12a\n\x9EV[a\x02Aa\x0BqV[`@Qa\x01\x87\x91\x90a\x1C|V[a\x02Va\x0C=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07R\x91\x90a\x1D\xFBV[a\x13\xB2V[V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05%W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x07\xAC\x90a\x1D\xAAV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07\xD8\x90a\x1D\xAAV[\x80\x15a\x08#W\x80`\x1F\x10a\x07\xFAWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x08#V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x08\x06W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x08\xBAW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x08gW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07|V[`\x1FT`\"\x80Ta\t\xE5\x92a\x01\0\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91c.O\x16\x1A\x91`\x02\x90\x81\x10a\t\x10Wa\t\x10a\x1DRV[\x90_R` _ \x01T`\"`\x03\x81T\x81\x10a\t-Wa\t-a\x1DRV[\x90_R` _ \x01T`\"`\x02\x81T\x81\x10a\tJWa\tJa\x1DRV[_\x91\x82R` \x90\x91 \x01T`@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\x86\x90\x1B\x16\x81R`\x04\x81\x01\x93\x90\x93R`$\x83\x01\x91\x90\x91R`D\x82\x01R`\x05`d\x82\x01R`\x84\x01[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\t\xBCW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\xE0\x91\x90a\x1D\xFBV[a\x14/V[`\x1FT`\"\x80Ta\x07W\x92a\x01\0\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91c.O\x16\x1A\x91`\x05\x90\x81\x10a\n#Wa\n#a\x1DRV[\x90_R` _ \x01T`\"`\x06\x81T\x81\x10a\n@Wa\n@a\x1DRV[_\x91\x82R` \x90\x91 \x01T`%T`@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\x86\x90\x1B\x16\x81R`\x04\x81\x01\x93\x90\x93R`$\x83\x01\x91\x90\x91R`D\x82\x01R`\x05`d\x82\x01R`\x84\x01a\t\xA1V[`\x1FT`\"\x80Ta\x07W\x92a\x01\0\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91c.O\x16\x1A\x91`\x01\x90\x81\x10a\n\xDCWa\n\xDCa\x1DRV[\x90_R` _ \x01T`\"`\x03\x81T\x81\x10a\n\xF9Wa\n\xF9a\x1DRV[\x90_R` _ \x01T`\"`\x02\x81T\x81\x10a\x0B\x16Wa\x0B\x16a\x1DRV[_\x91\x82R` \x90\x91 \x01T`@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\x86\x90\x1B\x16\x81R`\x04\x81\x01\x93\x90\x93R`$\x83\x01\x91\x90\x91R`D\x82\x01R`\x01`d\x82\x01R`\x84\x01a\x07\x13V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05%W\x83\x82\x90_R` _ \x01\x80Ta\x0B\xB1\x90a\x1D\xAAV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\xDD\x90a\x1D\xAAV[\x80\x15a\x0C(W\x80`\x1F\x10a\x0B\xFFWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C(V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0C\x0BW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0B\x94V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05%W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r'W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C\xD4W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0C_V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05%W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0E*W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\xD7W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\rbV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05%W\x83\x82\x90_R` _ \x01\x80Ta\x0E\x82\x90a\x1D\xAAV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0E\xAE\x90a\x1D\xAAV[\x80\x15a\x0E\xF9W\x80`\x1F\x10a\x0E\xD0Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0E\xF9V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0E\xDCW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0EeV[`\x08T_\x90`\xFF\x16\x15a\x0F$WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\xB2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xD6\x91\x90a\x1E!V[\x14\x15\x90P\x90V[`\x1FT`\"\x80Ta\x07W\x92a\x01\0\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91c.O\x16\x1A\x91`\x03\x90\x81\x10a\x10\x1BWa\x10\x1Ba\x1DRV[\x90_R` _ \x01T`\"`\x03\x81T\x81\x10a\x108Wa\x108a\x1DRV[\x90_R` _ \x01T`\"`\x03\x81T\x81\x10a\tJWa\tJa\x1DRV[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\xDBW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xB0WPPPPP\x90P\x90V[``a\x02\xFE\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x14\x81V[``a\x11\x0F\x84\x84a\x1D?V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x11'Wa\x11'a\x18\x86V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x11ZW\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x11EW\x90P[P\x90P\x83[\x83\x81\x10\x15a\x12[Wa\x12-\x86a\x11t\x83a\x15\xCFV[\x85`@Q` \x01a\x11\x87\x93\x92\x91\x90a\x1E8V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x11\xA3\x90a\x1D\xAAV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x11\xCF\x90a\x1D\xAAV[\x80\x15a\x12\x1AW\x80`\x1F\x10a\x11\xF1Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x12\x1AV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x11\xFDW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x17\0\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x128\x87\x84a\x1D?V[\x81Q\x81\x10a\x12HWa\x12Ha\x1DRV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x11_V[P\x94\x93PPPPV[``a\x12p\x84\x84a\x1D?V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\x88Wa\x12\x88a\x18\x86V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x12\xB1W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x12[Wa\x13\x84\x86a\x12\xCB\x83a\x15\xCFV[\x85`@Q` \x01a\x12\xDE\x93\x92\x91\x90a\x1E8V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x12\xFA\x90a\x1D\xAAV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x13&\x90a\x1D\xAAV[\x80\x15a\x13qW\x80`\x1F\x10a\x13HWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x13qV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x13TW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x17\x9F\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x13\x8F\x87\x84a\x1D?V[\x81Q\x81\x10a\x13\x9FWa\x13\x9Fa\x1DRV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x12\xB6V[`@Q\x7F\xA5\x98(\x85\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x81\x15\x15`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xA5\x98(\x85\x90`$\x01[_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x14\x16W__\xFD[PZ\xFA\x15\x80\x15a\x14(W=__>=_\xFD[PPPPPV[`@Q\x7F\x0C\x9F\xD5\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\x81R\x81\x15\x15`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x0C\x9F\xD5\x81\x90`$\x01a\x14\0V[``a\x14\x8D\x84\x84a\x1D?V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x14\xA5Wa\x14\xA5a\x18\x86V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x14\xCEW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x12[Wa\x15\xA1\x86a\x14\xE8\x83a\x15\xCFV[\x85`@Q` \x01a\x14\xFB\x93\x92\x91\x90a\x1E8V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x15\x17\x90a\x1D\xAAV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x15C\x90a\x1D\xAAV[\x80\x15a\x15\x8EW\x80`\x1F\x10a\x15eWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x15\x8EV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15qW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x182\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x15\xAC\x87\x84a\x1D?V[\x81Q\x81\x10a\x15\xBCWa\x15\xBCa\x1DRV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x14\xD3V[``\x81_\x03a\x16\x11WPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x16:W\x80a\x16$\x81a\x1E\xD5V[\x91Pa\x163\x90P`\n\x83a\x1F9V[\x91Pa\x16\x14V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16TWa\x16Ta\x18\x86V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x16~W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x02\xFEWa\x16\x93`\x01\x83a\x1D?V[\x91Pa\x16\xA0`\n\x86a\x1FLV[a\x16\xAB\x90`0a\x1F_V[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x16\xC0Wa\x16\xC0a\x1DRV[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x16\xF9`\n\x86a\x1F9V[\x94Pa\x16\x82V[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a\x17U\x90\x86\x90\x86\x90`\x04\x01a\x1FrV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x17oW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x17\x96\x91\x90\x81\x01\x90a\x1F\x9FV[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x17\xF3\x90\x86\x90\x86\x90`\x04\x01a\x1FrV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x18\x0EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x17\x96\x91\x90a\x1E!V[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x17\xF3\x90\x86\x90\x86\x90`\x04\x01a\x1FrV[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x18\xDCWa\x18\xDCa\x18\x86V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x18\xFDWa\x18\xFDa\x18\x86V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x19\x1DW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x193W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x19CW__\xFD[\x805a\x19Va\x19Q\x82a\x18\xE4V[a\x18\xB3V[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x19jW__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1A\x17W`?\x19\x87\x86\x03\x01\x84Ra\x1A\x02\x85\x83Qa\x19\x92V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x19\xE6V[P\x92\x96\x95PPPPPPV[` \x81R_a\x17\x96` \x83\x01\x84a\x19\x92V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1A\x82W\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\x1ANV[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x1A\xDBW`\x1F\x19\x85\x84\x03\x01\x88Ra\x1A\xC5\x83\x83Qa\x19\x92V[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x1A\xA9V[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1A\x17W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1BU`@\x87\x01\x82a\x1A\x8DV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1B\rV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1A\x82W\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1B\x84V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x1B\xF4W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x1B\xB4V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1A\x17W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x1CJ`@\x88\x01\x82a\x19\x92V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x1Ce\x81\x83a\x1B\xA2V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1C$V[` \x81R_a\x17\x96` \x83\x01\x84a\x1A\x8DV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1A\x17W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1C\xFC`@\x87\x01\x82a\x1B\xA2V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1C\xB4V[\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\x17\x99Wa\x17\x99a\x1D\x12V[\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x02\xFEa\x1D\xA4\x83\x86a\x1D\x7FV[\x84a\x1D\x7FV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1D\xBEW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x1D\xF5W\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x1E\x0BW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x1E\x1AW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x1E1W__\xFD[PQ\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\x81R_a\x1Ei`\x01\x83\x01\x86a\x1D\x7FV[\x7F[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x1E\x99`\x01\x82\x01\x86a\x1D\x7FV[\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\x81Ra\x1E\xCB`\x02\x82\x01\x85a\x1D\x7FV[\x96\x95PPPPPPV[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x1F\x05Wa\x1F\x05a\x1D\x12V[P`\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`\x12`\x04R`$_\xFD[_\x82a\x1FGWa\x1FGa\x1F\x0CV[P\x04\x90V[_\x82a\x1FZWa\x1FZa\x1F\x0CV[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a\x17\x99Wa\x17\x99a\x1D\x12V[`@\x81R_a\x1F\x84`@\x83\x01\x85a\x19\x92V[\x82\x81\x03` \x84\x01Ra\x1F\x96\x81\x85a\x19\x92V[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x1F\xAFW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xC5W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x1F\xD5W__\xFD[\x80Qa\x1F\xE3a\x19Q\x82a\x18\xE4V[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a\x1F\xF7W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV\xFE\xA2dipfsX\"\x12 \xB6\xE3\x98\xA4\xB1\xB6\x17H\xD1\xA0\xDE\xE6\x0CG\xA3\xB9O\xC3UV\xCC\x01\x1F4\xE3\xAF\x91\x8B\xEA%k\xE9dsolcC\0\x08\x1C\x003`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa);8\x03\x80a);\x839\x81\x01`@\x81\x90Ra\0.\x91a\x03+V[\x82\x82\x82\x82\x82\x82a\0?\x83Q`P\x14\x90V[a\0\x84W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x11`$\x82\x01RpBad genesis block`x\x1B`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\0\x8E\x84a\x01fV[\x90Pb\xFF\xFF\xFF\x82\x16\x15a\x01\tW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FPeriod start hash does not have `D\x82\x01R\x7Fwork. Hint: wrong byte order?\0\0\0`d\x82\x01R`\x84\x01a\0{V[_\x81\x81U`\x01\x82\x90U`\x02\x82\x90U\x81\x81R`\x04` R`@\x90 \x83\x90Ua\x012a\x07\xE0\x84a\x03\xFEV[a\x01<\x90\x84a\x04%V[_\x83\x81R`\x04` R`@\x90 Ua\x01S\x84a\x02&V[`\x05UPa\x05\xBD\x98PPPPPPPPPV[_`\x02\x80\x83`@Qa\x01x\x91\x90a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\x93W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x04NV[`@Q` \x01a\x01\xC8\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x01\xE2\x91a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\xFDW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02 \x91\x90a\x04NV[\x92\x91PPV[_a\x02 a\x023\x83a\x028V[a\x02CV[_a\x02 \x82\x82a\x02SV[_a\x02 a\xFF\xFF`\xD0\x1B\x83a\x02\xF7V[_\x80a\x02ja\x02c\x84`Ha\x04eV[\x85\x90a\x03\tV[`\xE8\x1C\x90P_\x84a\x02|\x85`Ka\x04eV[\x81Q\x81\x10a\x02\x8CWa\x02\x8Ca\x04xV[\x01` \x01Q`\xF8\x1C\x90P_a\x02\xBE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x02\xD1`\x03\x84a\x04\x8CV[`\xFF\x16\x90Pa\x02\xE2\x81a\x01\0a\x05\x88V[a\x02\xEC\x90\x83a\x05\x93V[\x97\x96PPPPPPPV[_a\x03\x02\x82\x84a\x05\xAAV[\x93\x92PPPV[_a\x03\x02\x83\x83\x01` \x01Q\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x03=W__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03RW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03bW__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03{Wa\x03{a\x03\x17V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x03\xA9Wa\x03\xA9a\x03\x17V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x03\xC0W__\xFD[\x81` \x84\x01` \x83\x01^_` \x92\x82\x01\x83\x01R\x90\x86\x01Q`@\x90\x96\x01Q\x90\x97\x95\x96P\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x04\x0CWa\x04\x0Ca\x03\xEAV[P\x06\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x04^W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02 Wa\x02 a\x04\x11V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[`\x01\x81[`\x01\x84\x11\x15a\x04\xE0W\x80\x85\x04\x81\x11\x15a\x04\xC4Wa\x04\xC4a\x04\x11V[`\x01\x84\x16\x15a\x04\xD2W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x04\xA9V[\x93P\x93\x91PPV[_\x82a\x04\xF6WP`\x01a\x02 V[\x81a\x05\x02WP_a\x02 V[\x81`\x01\x81\x14a\x05\x18W`\x02\x81\x14a\x05\"Wa\x05>V[`\x01\x91PPa\x02 V[`\xFF\x84\x11\x15a\x053Wa\x053a\x04\x11V[PP`\x01\x82\x1Ba\x02 V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x05aWP\x81\x81\na\x02 V[a\x05m_\x19\x84\x84a\x04\xA5V[\x80_\x19\x04\x82\x11\x15a\x05\x80Wa\x05\x80a\x04\x11V[\x02\x93\x92PPPV[_a\x03\x02\x83\x83a\x04\xE8V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x02 Wa\x02 a\x04\x11V[_\x82a\x05\xB8Wa\x05\xB8a\x03\xEAV[P\x04\x90V[a#q\x80a\x05\xCA_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\xADW\x80c\xB9\x85b\x1A\x11a\0}W\x80c\xE3\xD8\xD8\xD8\x11a\0cW\x80c\xE3\xD8\xD8\xD8\x14a\x02\"W\x80c\xE4q\xE7,\x14a\x02)W\x80c\xF5\x8D\xB0o\x14a\x02=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x13\x91\x90a!WV[`@Q` \x01a\x0C%\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\x90\x82\x90Ra\x0C]\x91a!AV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0CxW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x07\x91\x90a!WV[_\x83\x85\x14\x80\x15a\x0C\xAAWP\x82\x85\x14[\x15a\x0C\xB7WP`\x01a\x04\xF1V[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x0C\xFFW\x89\x83\x14a\x0C\xDEW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x0C\xF7W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x0C\xBDV[P\x82\x84\x03a\r\x13W_\x94PPPPPa\x04\xF1V[\x80\x82\x14a\r&W_\x94PPPPPa\x04\xF1V[P`\x01\x98\x97PPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\rYW_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\r9V[P\x80a\x05\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x80\x82\x81[a\r\xB8`\x04`\x01a!\x9BV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0E\x0CW_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\r\xF1W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0E\x04V[a\r\xFB\x81\x84a!\xB7V[\x95\x94PPPPPV[`\x01\x01a\r\xACV[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_`P\x82Qa\x0B~\x91\x90a!.V[__a\x0Eo\x85a\x0B\xC3V[\x90P_a\x0E{\x82a\r\xA7V[\x90P_a\x0E\x87\x86a\x19\xE6V[\x90P\x84\x80a\x0E\x9CWP\x80a\x0E\x9A\x88a\x19\xE6V[\x14[a\x0F\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x03.V[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x12\x0EWa\x0F(`P\x82a!\xCAV[a\x0F3\x90`\x01a!\xB7V[a\x0F=\x90\x87a!\xB7V[\x93Pa\x0FK\x8A\x82`Pa\x19\xF1V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x11!W\x84a\x10\xA1\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x10\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x11\n`\x04\x85a!.V[_\x03a\x11!W_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x11,\x8B\x83a\x1A\x16V[\x14a\x11yW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[\x86a\x11\x84\x8B\x83a\x1A\xAFV[\x14a\x11\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x03.V[\x82\x96P`P\x81a\x12\x07\x91\x90a!\xB7V[\x90Pa\x0F\x15V[P\x81a\x12\x19\x8Ba\x0B\xC3V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x12\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x12\xD4\x84a\x0B\xC3V[\x90P_a\x12\xE0\x86a\x0B\xC3V[\x90P`\x01T\x81\x14a\x133W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x03.V[_\x82\x81R`\x03` R`@\x90 Ta\x13\x8DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x13\x9B\x87`\x01T\x84\x87a\x0C\x9BV[a\x14\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x03.V[\x81a\x14\x19\x88\x88\x88a\x17\x80V[\x14a\x14\x8CW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[`\x01\x82\x90U`\x02\x87\x90U_a\x14\xA0\x86a\x1A\xC7V[\x90P`\x05T\x81\x14a\x14\xB1W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x15\x01a\x14\xFC\x86a\x0B\xC3V[a\r\xA7V[\x90P_a\x15\x10a\x14\xFC\x86a\x0B\xC3V[\x90Pa\x15\x1Ea\x07\xE0\x82a!.V[a\x07\xDF\x14a\x15\x94W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x03.V[a\x15\xA0\x82a\x07\xDFa!\xB7V[\x81\x14a\x16\x14W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x03.V[a\x16\x1D\x85a\x1A\xC7V[a\x16&\x87a\x1A\xC7V[\x14a\x16\x99W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x03.V[_a\x16\xA3\x85a\x19\xE6V[\x90P_a\x16\xD5a\x16\xB2\x89a\x19\xE6V[a\x16\xBB\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x16\xCA\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x1B\x0CV[\x90P\x81\x81\x83\x16\x14a\x17(W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_a\x172\x89a\x1A\xC7V[\x90P\x80`\x06T\x14\x15\x80\x15a\x17\\WPa\x07\xE0a\x17O`\x01Ta\r\xA7V[a\x17Y\x91\x90a!\xDDV[\x84\x11[\x15a\x17gW`\x06\x81\x90U[a\x17s\x88\x88`\x01a\x0EdV[\x99\x98PPPPPPPPPV[__a\x17\x8B\x85a\r\xA7V[\x90P_a\x17\x9Aa\x14\xFC\x86a\x0B\xC3V[\x90P_a\x17\xA9a\x14\xFC\x86a\x0B\xC3V[\x90P\x82\x82\x10\x15\x80\x15a\x17\xBBWP\x82\x81\x10\x15[a\x18-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x18:a\x07\xE0\x85a!.V[a\x18F\x85a\x07\xE0a!\xB7V[a\x18P\x91\x90a!\xDDV[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x18bWP\x80[\x15a\x18}Wa\x18p\x89a\x0B\xC3V[\x96PPPPPPPa\n\xA3V[\x81\x80\x15a\x18\x88WP\x80\x15[\x15a\x18\x96Wa\x18p\x88a\x0B\xC3V[\x81\x80\x15a\x18\xA0WP\x80[\x15a\x18\xC4W\x83\x85\x10\x15a\x18\xBBWa\x18\xB6\x88a\x0B\xC3V[a\x18pV[a\x18p\x89a\x0B\xC3V[a\x18\xCD\x88a\x1A\xC7V[a\x18\xD9a\x07\xE0\x86a!.V[a\x18\xE3\x91\x90a!\xF0V[a\x18\xEC\x8Aa\x1A\xC7V[a\x18\xF8a\x07\xE0\x88a!.V[a\x19\x02\x91\x90a!\xF0V[\x10\x15a\x18\xBBWa\x18p\x88a\x0B\xC3V[`\x07T_\x90`\xFF\x16\x15a\x19/WP`\x07Ta\x01\0\x90\x04`\xFF\x16a\n\xA3V[a\x19:\x84\x84\x84a\x1B\x94V[\x90Pa\n\xA3V[_` \x84Qa\x19P\x91\x90a!.V[\x15a\x19\\WP_a\x04\xF1V[\x83Q_\x03a\x19kWP_a\x04\xF1V[\x81\x85_[\x86Q\x81\x10\x15a\x19\xD9Wa\x19\x83`\x02\x84a!.V[`\x01\x03a\x19\xA7Wa\x19\xA0a\x19\x9A\x88\x83\x01` \x01Q\x90V[\x83a\x1B\xD5V[\x91Pa\x19\xC0V[a\x19\xBD\x82a\x19\xB8\x89\x84\x01` \x01Q\x90V[a\x1B\xD5V[\x91P[`\x01\x92\x90\x92\x1C\x91a\x19\xD2` \x82a!\xB7V[\x90Pa\x19oV[P\x90\x93\x14\x95\x94PPPPPV[_a\x05\x07\x82_a\x1A\x16V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x1A-a\x1A&\x84`Ha!\xB7V[\x85\x90a\x1B\xE0V[`\xE8\x1C\x90P_\x84a\x1A?\x85`Ka!\xB7V[\x81Q\x81\x10a\x1AOWa\x1AOa\"\x07V[\x01` \x01Q`\xF8\x1C\x90P_a\x1A\x81\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1A\x94`\x03\x84a\"4V[`\xFF\x16\x90Pa\x1A\xA5\x81a\x01\0a#0V[a\x08-\x90\x83a!\xF0V[_a\x05\x04a\x1A\xBE\x83`\x04a!\xB7V[\x84\x01` \x01Q\x90V[_a\x05\x07a\x1A\xD4\x83a\x19\xE6V[a\x1B\xEEV[_a\x05\x07a\x1A\xE6\x83a\x1C\x15V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1B\x18\x83\x85a\x1C!V[\x90Pa\x1B(b\x12u\0`\x04a\x1C|V[\x81\x10\x15a\x1B@Wa\x1B=b\x12u\0`\x04a\x1C|V[\x90P[a\x1BNb\x12u\0`\x04a\x1C\x87V[\x81\x11\x15a\x1BfWa\x1Bcb\x12u\0`\x04a\x1C\x87V[\x90P[_a\x1B~\x82a\x1Bx\x88b\x01\0\0a\x1C|V[\x90a\x1C\x87V[\x90Pa\n\x8Ab\x01\0\0a\x1Bx\x83b\x12u\0a\x1C|V[_\x82\x81[\x83\x81\x10\x15a\x1B\xCAW\x85\x82\x03a\x1B\xB2W`\x01\x92PPPa\n\xA3V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x1B\x98V[P_\x95\x94PPPPPV[_a\x05\x04\x83\x83a\x1C\xFAV[_a\x05\x04\x83\x83\x01` \x01Q\x90V[_a\x05\x07{\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\x83a\x1C|V[_a\x05\x07\x82`Da\x1B\xE0V[_\x82\x82\x11\x15a\x1CrW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x05\x04\x82\x84a!\xDDV[_a\x05\x04\x82\x84a!\xCAV[_\x82_\x03a\x1C\x96WP_a\x05\x07V[a\x1C\xA0\x82\x84a!\xF0V[\x90P\x81a\x1C\xAD\x84\x83a!\xCAV[\x14a\x05\x07W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x03.V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1D1W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DHW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1D_W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1DvW__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1D\x91W__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xA7W__\xFD[a\x1D\xB3\x8A\x82\x8B\x01a\x1D!V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xD2W__\xFD[a\x1D\xDE\x8A\x82\x8B\x01a\x1D!V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1D\xFE`\x80\x89\x01a\x1DfV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[____`\x80\x85\x87\x03\x12\x15a\x1E\x1FW__\xFD[PP\x825\x94` \x84\x015\x94P`@\x84\x015\x93``\x015\x92P\x90PV[__`@\x83\x85\x03\x12\x15a\x1ELW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1EkW__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1E\x85W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x9BW__\xFD[a\x1E\xA7\x87\x82\x88\x01a\x1D!V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\xC6W__\xFD[a\x1E\xD2\x87\x82\x88\x01a\x1D!V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1E\xF3W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x10W__\xFD[a\x1F\x1C\x89\x82\x8A\x01a\x1D!V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F;W__\xFD[a\x1FG\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1FtW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x8AW__\xFD[a\x1F\x96\x89\x82\x8A\x01a\x1D!V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xB5W__\xFD[a\x1F\xC1\x89\x82\x8A\x01a\x1D!V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xE0W__\xFD[a\x1F\xEC\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_____``\x86\x88\x03\x12\x15a \x12W__\xFD[\x855\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a /W__\xFD[a ;\x88\x82\x89\x01a\x1D!V[\x90\x95P\x93PP`@\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a ZW__\xFD[a f\x88\x82\x89\x01a\x1D!V[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[___``\x84\x86\x03\x12\x15a \x89W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a \xB1W__\xFD[\x825\x91Pa \xC1` \x84\x01a\x1DfV[\x90P\x92P\x92\x90PV[\x805\x80\x15\x15\x81\x14a\x1DvW__\xFD[__`@\x83\x85\x03\x12\x15a \xEAW__\xFD[a \xF3\x83a \xCAV[\x91Pa \xC1` \x84\x01a \xCAV[\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!^<#\x14a\x01\xDAW__\xFD[\x80c\x08\x13\x85*\x14a\x01gW\x80c\x1C\r\xA8\x1F\x14a\x01\x90W[__\xFD[a\x01za\x01u6`\x04a\x19\x0BV[a\x02\xBBV[`@Qa\x01\x87\x91\x90a\x19\xC0V[`@Q\x80\x91\x03\x90\xF3[a\x01\xA3a\x01\x9E6`\x04a\x19\x0BV[a\x03\x06V[`@Qa\x01\x87\x91\x90a\x1A#V[a\x01\xB8a\x03xV[`@Qa\x01\x87\x91\x90a\x1A5V[a\x01\xCDa\x03\xE5V[`@Qa\x01\x87\x91\x90a\x1A\xE7V[a\x01\xB8a\x05.V[a\x01\xB8a\x05\x99V[a\x01\xFDa\x01\xF86`\x04a\x19\x0BV[a\x06\x04V[`@Qa\x01\x87\x91\x90a\x1BkV[a\x02\x12a\x06GV[\0[a\x02\x1Ca\x07YV[`@Qa\x01\x87\x91\x90a\x1B\xFEV[a\x02\x12a\x08\xD2V[a\x02\x12a\n\x9EV[a\x02Aa\x0BqV[`@Qa\x01\x87\x91\x90a\x1C|V[a\x02Va\x0C=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07R\x91\x90a\x1D\xFBV[a\x13\xB2V[V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05%W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x07\xAC\x90a\x1D\xAAV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07\xD8\x90a\x1D\xAAV[\x80\x15a\x08#W\x80`\x1F\x10a\x07\xFAWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x08#V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x08\x06W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x08\xBAW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x08gW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07|V[`\x1FT`\"\x80Ta\t\xE5\x92a\x01\0\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91c.O\x16\x1A\x91`\x02\x90\x81\x10a\t\x10Wa\t\x10a\x1DRV[\x90_R` _ \x01T`\"`\x03\x81T\x81\x10a\t-Wa\t-a\x1DRV[\x90_R` _ \x01T`\"`\x02\x81T\x81\x10a\tJWa\tJa\x1DRV[_\x91\x82R` \x90\x91 \x01T`@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\x86\x90\x1B\x16\x81R`\x04\x81\x01\x93\x90\x93R`$\x83\x01\x91\x90\x91R`D\x82\x01R`\x05`d\x82\x01R`\x84\x01[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\t\xBCW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\xE0\x91\x90a\x1D\xFBV[a\x14/V[`\x1FT`\"\x80Ta\x07W\x92a\x01\0\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91c.O\x16\x1A\x91`\x05\x90\x81\x10a\n#Wa\n#a\x1DRV[\x90_R` _ \x01T`\"`\x06\x81T\x81\x10a\n@Wa\n@a\x1DRV[_\x91\x82R` \x90\x91 \x01T`%T`@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\x86\x90\x1B\x16\x81R`\x04\x81\x01\x93\x90\x93R`$\x83\x01\x91\x90\x91R`D\x82\x01R`\x05`d\x82\x01R`\x84\x01a\t\xA1V[`\x1FT`\"\x80Ta\x07W\x92a\x01\0\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91c.O\x16\x1A\x91`\x01\x90\x81\x10a\n\xDCWa\n\xDCa\x1DRV[\x90_R` _ \x01T`\"`\x03\x81T\x81\x10a\n\xF9Wa\n\xF9a\x1DRV[\x90_R` _ \x01T`\"`\x02\x81T\x81\x10a\x0B\x16Wa\x0B\x16a\x1DRV[_\x91\x82R` \x90\x91 \x01T`@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\x86\x90\x1B\x16\x81R`\x04\x81\x01\x93\x90\x93R`$\x83\x01\x91\x90\x91R`D\x82\x01R`\x01`d\x82\x01R`\x84\x01a\x07\x13V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05%W\x83\x82\x90_R` _ \x01\x80Ta\x0B\xB1\x90a\x1D\xAAV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\xDD\x90a\x1D\xAAV[\x80\x15a\x0C(W\x80`\x1F\x10a\x0B\xFFWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C(V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0C\x0BW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0B\x94V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05%W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r'W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C\xD4W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0C_V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05%W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0E*W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\xD7W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\rbV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05%W\x83\x82\x90_R` _ \x01\x80Ta\x0E\x82\x90a\x1D\xAAV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0E\xAE\x90a\x1D\xAAV[\x80\x15a\x0E\xF9W\x80`\x1F\x10a\x0E\xD0Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0E\xF9V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0E\xDCW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0EeV[`\x08T_\x90`\xFF\x16\x15a\x0F$WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\xB2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xD6\x91\x90a\x1E!V[\x14\x15\x90P\x90V[`\x1FT`\"\x80Ta\x07W\x92a\x01\0\x90\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91c.O\x16\x1A\x91`\x03\x90\x81\x10a\x10\x1BWa\x10\x1Ba\x1DRV[\x90_R` _ \x01T`\"`\x03\x81T\x81\x10a\x108Wa\x108a\x1DRV[\x90_R` _ \x01T`\"`\x03\x81T\x81\x10a\tJWa\tJa\x1DRV[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\xDBW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xB0WPPPPP\x90P\x90V[``a\x02\xFE\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x14\x81V[``a\x11\x0F\x84\x84a\x1D?V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x11'Wa\x11'a\x18\x86V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x11ZW\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x11EW\x90P[P\x90P\x83[\x83\x81\x10\x15a\x12[Wa\x12-\x86a\x11t\x83a\x15\xCFV[\x85`@Q` \x01a\x11\x87\x93\x92\x91\x90a\x1E8V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x11\xA3\x90a\x1D\xAAV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x11\xCF\x90a\x1D\xAAV[\x80\x15a\x12\x1AW\x80`\x1F\x10a\x11\xF1Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x12\x1AV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x11\xFDW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x17\0\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x128\x87\x84a\x1D?V[\x81Q\x81\x10a\x12HWa\x12Ha\x1DRV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x11_V[P\x94\x93PPPPV[``a\x12p\x84\x84a\x1D?V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\x88Wa\x12\x88a\x18\x86V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x12\xB1W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x12[Wa\x13\x84\x86a\x12\xCB\x83a\x15\xCFV[\x85`@Q` \x01a\x12\xDE\x93\x92\x91\x90a\x1E8V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x12\xFA\x90a\x1D\xAAV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x13&\x90a\x1D\xAAV[\x80\x15a\x13qW\x80`\x1F\x10a\x13HWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x13qV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x13TW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x17\x9F\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x13\x8F\x87\x84a\x1D?V[\x81Q\x81\x10a\x13\x9FWa\x13\x9Fa\x1DRV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x12\xB6V[`@Q\x7F\xA5\x98(\x85\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\x81\x15\x15`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xA5\x98(\x85\x90`$\x01[_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x14\x16W__\xFD[PZ\xFA\x15\x80\x15a\x14(W=__>=_\xFD[PPPPPV[`@Q\x7F\x0C\x9F\xD5\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\x81R\x81\x15\x15`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x0C\x9F\xD5\x81\x90`$\x01a\x14\0V[``a\x14\x8D\x84\x84a\x1D?V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x14\xA5Wa\x14\xA5a\x18\x86V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x14\xCEW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x12[Wa\x15\xA1\x86a\x14\xE8\x83a\x15\xCFV[\x85`@Q` \x01a\x14\xFB\x93\x92\x91\x90a\x1E8V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x15\x17\x90a\x1D\xAAV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x15C\x90a\x1D\xAAV[\x80\x15a\x15\x8EW\x80`\x1F\x10a\x15eWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x15\x8EV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15qW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x182\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x15\xAC\x87\x84a\x1D?V[\x81Q\x81\x10a\x15\xBCWa\x15\xBCa\x1DRV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x14\xD3V[``\x81_\x03a\x16\x11WPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x16:W\x80a\x16$\x81a\x1E\xD5V[\x91Pa\x163\x90P`\n\x83a\x1F9V[\x91Pa\x16\x14V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16TWa\x16Ta\x18\x86V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x16~W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x02\xFEWa\x16\x93`\x01\x83a\x1D?V[\x91Pa\x16\xA0`\n\x86a\x1FLV[a\x16\xAB\x90`0a\x1F_V[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x16\xC0Wa\x16\xC0a\x1DRV[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x16\xF9`\n\x86a\x1F9V[\x94Pa\x16\x82V[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a\x17U\x90\x86\x90\x86\x90`\x04\x01a\x1FrV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x17oW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x17\x96\x91\x90\x81\x01\x90a\x1F\x9FV[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x17\xF3\x90\x86\x90\x86\x90`\x04\x01a\x1FrV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x18\x0EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x17\x96\x91\x90a\x1E!V[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x17\xF3\x90\x86\x90\x86\x90`\x04\x01a\x1FrV[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x18\xDCWa\x18\xDCa\x18\x86V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x18\xFDWa\x18\xFDa\x18\x86V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x19\x1DW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x193W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x19CW__\xFD[\x805a\x19Va\x19Q\x82a\x18\xE4V[a\x18\xB3V[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x19jW__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1A\x17W`?\x19\x87\x86\x03\x01\x84Ra\x1A\x02\x85\x83Qa\x19\x92V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x19\xE6V[P\x92\x96\x95PPPPPPV[` \x81R_a\x17\x96` \x83\x01\x84a\x19\x92V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1A\x82W\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\x1ANV[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x1A\xDBW`\x1F\x19\x85\x84\x03\x01\x88Ra\x1A\xC5\x83\x83Qa\x19\x92V[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x1A\xA9V[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1A\x17W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1BU`@\x87\x01\x82a\x1A\x8DV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1B\rV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1A\x82W\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1B\x84V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x1B\xF4W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x1B\xB4V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1A\x17W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x1CJ`@\x88\x01\x82a\x19\x92V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x1Ce\x81\x83a\x1B\xA2V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1C$V[` \x81R_a\x17\x96` \x83\x01\x84a\x1A\x8DV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1A\x17W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1C\xFC`@\x87\x01\x82a\x1B\xA2V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1C\xB4V[\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\x17\x99Wa\x17\x99a\x1D\x12V[\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x02\xFEa\x1D\xA4\x83\x86a\x1D\x7FV[\x84a\x1D\x7FV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1D\xBEW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x1D\xF5W\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x1E\x0BW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x1E\x1AW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x1E1W__\xFD[PQ\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\x81R_a\x1Ei`\x01\x83\x01\x86a\x1D\x7FV[\x7F[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x1E\x99`\x01\x82\x01\x86a\x1D\x7FV[\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\x81Ra\x1E\xCB`\x02\x82\x01\x85a\x1D\x7FV[\x96\x95PPPPPPV[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x1F\x05Wa\x1F\x05a\x1D\x12V[P`\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`\x12`\x04R`$_\xFD[_\x82a\x1FGWa\x1FGa\x1F\x0CV[P\x04\x90V[_\x82a\x1FZWa\x1FZa\x1F\x0CV[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a\x17\x99Wa\x17\x99a\x1D\x12V[`@\x81R_a\x1F\x84`@\x83\x01\x85a\x19\x92V[\x82\x81\x03` \x84\x01Ra\x1F\x96\x81\x85a\x19\x92V[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x1F\xAFW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xC5W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x1F\xD5W__\xFD[\x80Qa\x1F\xE3a\x19Q\x82a\x18\xE4V[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a\x1F\xF7W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV\xFE\xA2dipfsX\"\x12 \xB6\xE3\x98\xA4\xB1\xB6\x17H\xD1\xA0\xDE\xE6\x0CG\xA3\xB9O\xC3UV\xCC\x01\x1F4\xE3\xAF\x91\x8B\xEA%k\xE9dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. -```solidity -event log(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolConstructor for constructorCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getBlockHeights(string,uint256,uint256)` and selector `0xfad06b8f`. -```solidity -function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getBlockHeightsCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getBlockHeights(string,uint256,uint256)`](getBlockHeightsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getBlockHeightsReturn { - #[allow(missing_docs)] - pub elements: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getBlockHeightsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - #[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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getBlockHeightsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getBlockHeightsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getBlockHeights(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [250u8, 208u8, 107u8, 143u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getDigestLes(string,uint256,uint256)` and selector `0x44badbb6`. -```solidity -function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getDigestLesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getDigestLes(string,uint256,uint256)`](getDigestLesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getDigestLesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getDigestLesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getDigestLesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getDigestLesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array< - alloy::sol_types::sol_data::FixedBytes<32>, - >, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getDigestLes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [68u8, 186u8, 219u8, 182u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaderHexes(string,uint256,uint256)` and selector `0x0813852a`. -```solidity -function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaderHexes(string,uint256,uint256)`](getHeaderHexesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeaderHexesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getHeaderHexesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getHeaderHexesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Bytes, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaderHexes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [8u8, 19u8, 133u8, 42u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaders(string,uint256,uint256)` and selector `0x1c0da81f`. -```solidity -function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaders(string,uint256,uint256)`](getHeadersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersReturn { - #[allow(missing_docs)] - pub headers: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersReturn) -> Self { - (value.headers,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { headers: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getHeadersCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Bytes; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaders(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [28u8, 13u8, 168u8, 31u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testLeftAndRightAndAncestorSame()` and selector `0xdec5a944`. -```solidity -function testLeftAndRightAndAncestorSame() external view; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testLeftAndRightAndAncestorSameCall; - ///Container type for the return parameters of the [`testLeftAndRightAndAncestorSame()`](testLeftAndRightAndAncestorSameCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testLeftAndRightAndAncestorSameReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testLeftAndRightAndAncestorSameCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testLeftAndRightAndAncestorSameCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testLeftAndRightAndAncestorSameReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testLeftAndRightAndAncestorSameReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testLeftAndRightAndAncestorSameReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testLeftAndRightAndAncestorSameCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testLeftAndRightAndAncestorSameReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testLeftAndRightAndAncestorSame()"; - const SELECTOR: [u8; 4] = [222u8, 197u8, 169u8, 68u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testLeftAndRightAndAncestorSameReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testReturnsFalseIfLimitExceeded()` and selector `0x7ba3c18c`. -```solidity -function testReturnsFalseIfLimitExceeded() external view; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testReturnsFalseIfLimitExceededCall; - ///Container type for the return parameters of the [`testReturnsFalseIfLimitExceeded()`](testReturnsFalseIfLimitExceededCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testReturnsFalseIfLimitExceededReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testReturnsFalseIfLimitExceededCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testReturnsFalseIfLimitExceededCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testReturnsFalseIfLimitExceededReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testReturnsFalseIfLimitExceededReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testReturnsFalseIfLimitExceededReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testReturnsFalseIfLimitExceededCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testReturnsFalseIfLimitExceededReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testReturnsFalseIfLimitExceeded()"; - const SELECTOR: [u8; 4] = [123u8, 163u8, 193u8, 140u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testReturnsFalseIfLimitExceededReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testReturnsFalseIfMoreRecentAncestorFound()` and selector `0x51712e27`. -```solidity -function testReturnsFalseIfMoreRecentAncestorFound() external view; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testReturnsFalseIfMoreRecentAncestorFoundCall; - ///Container type for the return parameters of the [`testReturnsFalseIfMoreRecentAncestorFound()`](testReturnsFalseIfMoreRecentAncestorFoundCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testReturnsFalseIfMoreRecentAncestorFoundReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testReturnsFalseIfMoreRecentAncestorFoundCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testReturnsFalseIfMoreRecentAncestorFoundCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testReturnsFalseIfMoreRecentAncestorFoundReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testReturnsFalseIfMoreRecentAncestorFoundReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testReturnsFalseIfMoreRecentAncestorFoundReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testReturnsFalseIfMoreRecentAncestorFoundCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testReturnsFalseIfMoreRecentAncestorFoundReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testReturnsFalseIfMoreRecentAncestorFound()"; - const SELECTOR: [u8; 4] = [81u8, 113u8, 46u8, 39u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testReturnsFalseIfMoreRecentAncestorFoundReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testReturnsTrueIfWithinLimit()` and selector `0x7a04c715`. -```solidity -function testReturnsTrueIfWithinLimit() external view; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testReturnsTrueIfWithinLimitCall; - ///Container type for the return parameters of the [`testReturnsTrueIfWithinLimit()`](testReturnsTrueIfWithinLimitCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testReturnsTrueIfWithinLimitReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testReturnsTrueIfWithinLimitCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testReturnsTrueIfWithinLimitCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testReturnsTrueIfWithinLimitReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testReturnsTrueIfWithinLimitReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testReturnsTrueIfWithinLimitReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testReturnsTrueIfWithinLimitCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testReturnsTrueIfWithinLimitReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testReturnsTrueIfWithinLimit()"; - const SELECTOR: [u8; 4] = [122u8, 4u8, 199u8, 21u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testReturnsTrueIfWithinLimitReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`FullRelayIsMostAncestorTest`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum FullRelayIsMostAncestorTestCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - getBlockHeights(getBlockHeightsCall), - #[allow(missing_docs)] - getDigestLes(getDigestLesCall), - #[allow(missing_docs)] - getHeaderHexes(getHeaderHexesCall), - #[allow(missing_docs)] - getHeaders(getHeadersCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - testLeftAndRightAndAncestorSame(testLeftAndRightAndAncestorSameCall), - #[allow(missing_docs)] - testReturnsFalseIfLimitExceeded(testReturnsFalseIfLimitExceededCall), - #[allow(missing_docs)] - testReturnsFalseIfMoreRecentAncestorFound( - testReturnsFalseIfMoreRecentAncestorFoundCall, - ), - #[allow(missing_docs)] - testReturnsTrueIfWithinLimit(testReturnsTrueIfWithinLimitCall), - } - #[automatically_derived] - impl FullRelayIsMostAncestorTestCalls { - /// 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, 19u8, 133u8, 42u8], - [28u8, 13u8, 168u8, 31u8], - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [68u8, 186u8, 219u8, 182u8], - [81u8, 113u8, 46u8, 39u8], - [102u8, 217u8, 169u8, 160u8], - [122u8, 4u8, 199u8, 21u8], - [123u8, 163u8, 193u8, 140u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [222u8, 197u8, 169u8, 68u8], - [226u8, 12u8, 159u8, 113u8], - [250u8, 118u8, 38u8, 212u8], - [250u8, 208u8, 107u8, 143u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for FullRelayIsMostAncestorTestCalls { - const NAME: &'static str = "FullRelayIsMostAncestorTestCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 20usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::getBlockHeights(_) => { - ::SELECTOR - } - Self::getDigestLes(_) => { - ::SELECTOR - } - Self::getHeaderHexes(_) => { - ::SELECTOR - } - Self::getHeaders(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::testLeftAndRightAndAncestorSame(_) => { - ::SELECTOR - } - Self::testReturnsFalseIfLimitExceeded(_) => { - ::SELECTOR - } - Self::testReturnsFalseIfMoreRecentAncestorFound(_) => { - ::SELECTOR - } - Self::testReturnsTrueIfWithinLimit(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::getHeaderHexes) - } - getHeaderHexes - }, - { - fn getHeaders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::getHeaders) - } - getHeaders - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::targetContracts) - } - targetContracts - }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::getDigestLes) - } - getDigestLes - }, - { - fn testReturnsFalseIfMoreRecentAncestorFound( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - FullRelayIsMostAncestorTestCalls::testReturnsFalseIfMoreRecentAncestorFound, - ) - } - testReturnsFalseIfMoreRecentAncestorFound - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - FullRelayIsMostAncestorTestCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn testReturnsTrueIfWithinLimit( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - FullRelayIsMostAncestorTestCalls::testReturnsTrueIfWithinLimit, - ) - } - testReturnsTrueIfWithinLimit - }, - { - fn testReturnsFalseIfLimitExceeded( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - FullRelayIsMostAncestorTestCalls::testReturnsFalseIfLimitExceeded, - ) - } - testReturnsFalseIfLimitExceeded - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(FullRelayIsMostAncestorTestCalls::failed) - } - failed - }, - { - fn testLeftAndRightAndAncestorSame( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - FullRelayIsMostAncestorTestCalls::testLeftAndRightAndAncestorSame, - ) - } - testLeftAndRightAndAncestorSame - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::excludeContracts) - } - excludeContracts - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(FullRelayIsMostAncestorTestCalls::IS_TEST) - } - IS_TEST - }, - { - fn getBlockHeights( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::getBlockHeights) - } - getBlockHeights - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::getHeaderHexes) - } - getHeaderHexes - }, - { - fn getHeaders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::getHeaders) - } - getHeaders - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::targetContracts) - } - targetContracts - }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::getDigestLes) - } - getDigestLes - }, - { - fn testReturnsFalseIfMoreRecentAncestorFound( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayIsMostAncestorTestCalls::testReturnsFalseIfMoreRecentAncestorFound, - ) - } - testReturnsFalseIfMoreRecentAncestorFound - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayIsMostAncestorTestCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn testReturnsTrueIfWithinLimit( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayIsMostAncestorTestCalls::testReturnsTrueIfWithinLimit, - ) - } - testReturnsTrueIfWithinLimit - }, - { - fn testReturnsFalseIfLimitExceeded( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayIsMostAncestorTestCalls::testReturnsFalseIfLimitExceeded, - ) - } - testReturnsFalseIfLimitExceeded - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::failed) - } - failed - }, - { - fn testLeftAndRightAndAncestorSame( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayIsMostAncestorTestCalls::testLeftAndRightAndAncestorSame, - ) - } - testLeftAndRightAndAncestorSame - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::excludeContracts) - } - excludeContracts - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::IS_TEST) - } - IS_TEST - }, - { - fn getBlockHeights( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayIsMostAncestorTestCalls::getBlockHeights) - } - getBlockHeights - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::getBlockHeights(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getDigestLes(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getHeaders(inner) => { - ::abi_encoded_size(inner) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testLeftAndRightAndAncestorSame(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testReturnsFalseIfLimitExceeded(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testReturnsFalseIfMoreRecentAncestorFound(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testReturnsTrueIfWithinLimit(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::getBlockHeights(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getDigestLes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testLeftAndRightAndAncestorSame(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testReturnsFalseIfLimitExceeded(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testReturnsFalseIfMoreRecentAncestorFound(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testReturnsTrueIfWithinLimit(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`FullRelayIsMostAncestorTest`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum FullRelayIsMostAncestorTestEvents { - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl FullRelayIsMostAncestorTestEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for FullRelayIsMostAncestorTestEvents { - const NAME: &'static str = "FullRelayIsMostAncestorTestEvents"; - const COUNT: usize = 22usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 FullRelayIsMostAncestorTestEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`FullRelayIsMostAncestorTest`](self) contract instance. - -See the [wrapper's documentation](`FullRelayIsMostAncestorTestInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> FullRelayIsMostAncestorTestInstance { - FullRelayIsMostAncestorTestInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - FullRelayIsMostAncestorTestInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - FullRelayIsMostAncestorTestInstance::::deploy_builder(provider) - } - /**A [`FullRelayIsMostAncestorTest`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`FullRelayIsMostAncestorTest`](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 FullRelayIsMostAncestorTestInstance< - P, - N = alloy_contract::private::Ethereum, - > { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for FullRelayIsMostAncestorTestInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("FullRelayIsMostAncestorTestInstance") - .field(&self.address) - .finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayIsMostAncestorTestInstance { - /**Creates a new wrapper around an on-chain [`FullRelayIsMostAncestorTest`](self) contract instance. - -See the [wrapper's documentation](`FullRelayIsMostAncestorTestInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 FullRelayIsMostAncestorTestInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> FullRelayIsMostAncestorTestInstance { - FullRelayIsMostAncestorTestInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayIsMostAncestorTestInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`getBlockHeights`] function. - pub fn getBlockHeights( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getBlockHeightsCall, N> { - self.call_builder( - &getBlockHeightsCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getDigestLes`] function. - pub fn getDigestLes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getDigestLesCall, N> { - self.call_builder( - &getDigestLesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaderHexes`] function. - pub fn getHeaderHexes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeaderHexesCall, N> { - self.call_builder( - &getHeaderHexesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaders`] function. - pub fn getHeaders( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeadersCall, N> { - self.call_builder( - &getHeadersCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`testLeftAndRightAndAncestorSame`] function. - pub fn testLeftAndRightAndAncestorSame( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testLeftAndRightAndAncestorSameCall, N> { - self.call_builder(&testLeftAndRightAndAncestorSameCall) - } - ///Creates a new call builder for the [`testReturnsFalseIfLimitExceeded`] function. - pub fn testReturnsFalseIfLimitExceeded( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testReturnsFalseIfLimitExceededCall, N> { - self.call_builder(&testReturnsFalseIfLimitExceededCall) - } - ///Creates a new call builder for the [`testReturnsFalseIfMoreRecentAncestorFound`] function. - pub fn testReturnsFalseIfMoreRecentAncestorFound( - &self, - ) -> alloy_contract::SolCallBuilder< - &P, - testReturnsFalseIfMoreRecentAncestorFoundCall, - N, - > { - self.call_builder(&testReturnsFalseIfMoreRecentAncestorFoundCall) - } - ///Creates a new call builder for the [`testReturnsTrueIfWithinLimit`] function. - pub fn testReturnsTrueIfWithinLimit( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testReturnsTrueIfWithinLimitCall, N> { - self.call_builder(&testReturnsTrueIfWithinLimitCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayIsMostAncestorTestInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/fullrelaymarkheaviesttest.rs b/crates/bindings/src/fullrelaymarkheaviesttest.rs deleted file mode 100644 index 002c86a15..000000000 --- a/crates/bindings/src/fullrelaymarkheaviesttest.rs +++ /dev/null @@ -1,9284 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface FullRelayMarkHeaviestTest { - event NewTip(bytes32 indexed _from, bytes32 indexed _to, bytes32 indexed _gcd); - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - constructor(); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); - function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); - function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); - function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function testPassedInAncestorNotTheHeaviestCommon() external; - function testPassedInBestKnowIsUnknown() external; - function testPassedInNotTheBestKnown() external; - function testSuccessfullyMarkHeaviest() external; -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getBlockHeights", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getDigestLes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes32[]", - "internalType": "bytes32[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaderHexes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes[]", - "internalType": "bytes[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaders", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "headers", - "type": "bytes", - "internalType": "bytes" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testPassedInAncestorNotTheHeaviestCommon", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testPassedInBestKnowIsUnknown", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testPassedInNotTheBestKnown", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testSuccessfullyMarkHeaviest", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "event", - "name": "NewTip", - "inputs": [ - { - "name": "_from", - "type": "bytes32", - "indexed": true, - "internalType": "bytes32" - }, - { - "name": "_to", - "type": "bytes32", - "indexed": true, - "internalType": "bytes32" - }, - { - "name": "_gcd", - "type": "bytes32", - "indexed": true, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 FullRelayMarkHeaviestTest { - use super::*; - use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15a\0,W__\xFD[P`@Q\x80`@\x01`@R\x80`\x1C\x81R` \x01\x7FheadersReorgAndRetarget.json\0\0\0\0\x81RP`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k\x05\xCC\xEC\xAD\xCC\xAEm.e\xCD\x0C\xAF`\xA3\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x0F\x81R` \x01n\x0B\x99\xD9[\x99\\\xDA\\\xCB\x9A\x19ZY\xDA\x1D`\x8A\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x19\x81R` \x01\x7F.oldPeriodStart.digest_le\0\0\0\0\0\0\0\x81RP__Q` aa\xE0_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x16c\xD90\xA0\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01/W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01V\x91\x90\x81\x01\x90a\x0F\xB0V[\x90P_\x81\x86`@Q` \x01a\x01l\x92\x91\x90a\x10\x0BV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Rc`\xF9\xBB\x11`\xE0\x1B\x82R\x91P_Q` aa\xE0_9_Q\x90_R\x90c`\xF9\xBB\x11\x90a\x01\xAC\x90\x84\x90`\x04\x01a\x10}V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xC6W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01\xED\x91\x90\x81\x01\x90a\x0F\xB0V[` \x90a\x01\xFA\x90\x82a\x11\x13V[Pa\x02\x91\x85` \x80Ta\x02\x0C\x90a\x10\x8FV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x028\x90a\x10\x8FV[\x80\x15a\x02\x83W\x80`\x1F\x10a\x02ZWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02\x83V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02fW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\t~\x91PPV[a\x03'\x85` \x80Ta\x02\xA2\x90a\x10\x8FV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\xCE\x90a\x10\x8FV[\x80\x15a\x03\x19W\x80`\x1F\x10a\x02\xF0Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\x19V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02\xFCW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\t\xFD\x91PPV[a\x03\xBD\x85` \x80Ta\x038\x90a\x10\x8FV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03d\x90a\x10\x8FV[\x80\x15a\x03\xAFW\x80`\x1F\x10a\x03\x86Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xAFV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\x92W\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\np\x91PPV[`@Qa\x03\xC9\x90a\x0E\x17V[a\x03\xD5\x93\x92\x91\x90a\x11\xCDV[`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03\xEEW=__>=_\xFD[P`\x1F`\x01a\x01\0\n\x81T\x81`\x01`\x01`\xA0\x1B\x03\x02\x19\x16\x90\x83`\x01`\x01`\xA0\x1B\x03\x16\x02\x17\x90UPPPPPPPa\x04U`@Q\x80`@\x01`@R\x80`\x10\x81R` \x01o892\xA92\xBA0\xB93\xB2\xBA!\xB40\xB4\xB7`\x81\x1B\x81RP_`\x05a\n\xA4` \x1B` \x1CV[\x80Qa\x04i\x91`!\x91` \x90\x91\x01\x90a\x0E$V[P`@\x80Q\x80\x82\x01\x90\x91R`\x11\x81R_Q` aa\xC0_9_Q\x90_R` \x82\x01Ra\x04\x97\x90_`\x08a\n\xA4V[\x80Qa\x04\xAB\x91`\"\x91` \x90\x91\x01\x90a\x0E$V[P`@\x80Q\x80\x82\x01\x90\x91R`\x10\x81Ro892\xA92\xBA0\xB93\xB2\xBA!\xB40\xB4\xB7`\x81\x1B` \x82\x01Ra\x04\xDF\x90_`\x05a\n\xDBV[\x80Qa\x04\xF3\x91`#\x91` \x90\x91\x01\x90a\x0ExV[P`@\x80Q\x80\x82\x01\x90\x91R`\x11\x81R_Q` aa\xC0_9_Q\x90_R` \x82\x01Ra\x05!\x90_`\x08a\n\xDBV[\x80Qa\x055\x91`$\x91` \x90\x91\x01\x90a\x0ExV[P_a\x05q`@Q\x80`@\x01`@R\x80`\x10\x81R` \x01o892\xA92\xBA0\xB93\xB2\xBA!\xB40\xB4\xB7`\x81\x1B\x81RP_`\x05a\x0B\x10` \x1B` \x1CV[\x90P_a\x05\xA8`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01_Q` aa\xC0_9_Q\x90_R\x81RP_`\x08a\x0B\x10` \x1B` \x1CV[\x90P_a\x05\xE5`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01_Q` aa\xC0_9_Q\x90_R\x81RP_`\x02`\x08a\x05\xE0\x91\x90a\x12\x05V[a\x0B\x10V[\x90Pa\x06\"`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01q\x05\xCD\xEEN\r\x0C-\xCB\xE6\x86f\xE6\x86\xE7\x05\xCD\x0C\xAF`s\x1B\x81RP` \x80Ta\x02\x0C\x90a\x10\x8FV[`'\x90a\x06/\x90\x82a\x11\x13V[Pa\x06v`@Q\x80`@\x01`@R\x80`\x18\x81R` \x01\x7F.orphan_437478.digest_le\0\0\0\0\0\0\0\0\x81RP` \x80Ta\x038\x90a\x10\x8FV[`(U`@Q_\x90a\x06\x8F\x90\x83\x90`'\x90` \x01a\x12\x18V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90Pa\x06\xE6`@Q\x80`@\x01`@R\x80`\x13\x81R` \x01\x7F.oldPeriodStart.hex\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x80Ta\x02\x0C\x90a\x10\x8FV[`)\x90a\x06\xF3\x90\x82a\x11\x13V[Pa\x07:`@Q\x80`@\x01`@R\x80`\x19\x81R` \x01\x7F.oldPeriodStart.digest_le\0\0\0\0\0\0\0\x81RP` \x80Ta\x038\x90a\x10\x8FV[`*\x81\x90UPa\x07u`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k\x05\xCC\xEC\xAD\xCC\xAEm.e\xCD\x0C\xAF`\xA3\x1B\x81RP` \x80Ta\x02\x0C\x90a\x10\x8FV[`%\x90a\x07\x82\x90\x82a\x11\x13V[Pa\x07\xBE`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01q.genesis.digest_le`p\x1B\x81RP` \x80Ta\x038\x90a\x10\x8FV[`&U`\x1FT`@Qce\xDAA\xB9`\xE0\x1B\x81Ra\x01\0\x90\x91\x04`\x01`\x01`\xA0\x1B\x03\x16\x90ce\xDAA\xB9\x90a\x07\xF8\x90`%\x90\x88\x90`\x04\x01a\x13\x14V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x08\x14W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x088\x91\x90a\x138V[P`\x1FTa\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16c\x7F\xA67\xFC`)`!a\x08_`\x01`\x05a\x12\x05V[\x81T\x81\x10a\x08oWa\x08oa\x13^V[\x90_R` _ \x01\x86`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x08\x96\x93\x92\x91\x90a\x13rV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x08\xB2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\xD6\x91\x90a\x138V[P`\x1FTa\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16c\x7F\xA67\xFC`)`!a\x08\xFD`\x01`\x05a\x12\x05V[\x81T\x81\x10a\t\rWa\t\ra\x13^V[\x90_R` _ \x01\x84`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\t4\x93\x92\x91\x90a\x13rV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\tPW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\tt\x91\x90a\x138V[PPPPPa\x14\x96V[`@Qc\x1F\xB2C}`\xE3\x1B\x81R``\x90_Q` aa\xE0_9_Q\x90_R\x90c\xFD\x92\x1B\xE8\x90a\t\xB3\x90\x86\x90\x86\x90`\x04\x01a\x13\xB4V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\t\xCDW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\t\xF4\x91\x90\x81\x01\x90a\x0F\xB0V[\x90P[\x92\x91PPV[`@QcV\xEE\xF1[`\xE1\x1B\x81R_\x90_Q` aa\xE0_9_Q\x90_R\x90c\xAD\xDD\xE2\xB6\x90a\n1\x90\x86\x90\x86\x90`\x04\x01a\x13\xB4V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\nLW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\xF4\x91\x90a\x13\xC6V[`@Qc\x17w\xE5\x9D`\xE0\x1B\x81R_\x90_Q` aa\xE0_9_Q\x90_R\x90c\x17w\xE5\x9D\x90a\n1\x90\x86\x90\x86\x90`\x04\x01a\x13\xB4V[``a\n\xD3\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01b\r\x0C\xAF`\xEB\x1B\x81RPa\x0B\x82` \x1B` \x1CV[\x94\x93PPPPV[``a\n\xD3\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01hdigest_le`\xB8\x1B\x81RPa\x0CX` \x1B` \x1CV[``_a\x0B\x1E\x85\x85\x85a\n\xA4V[\x90P_[a\x0B,\x85\x85a\x12\x05V[\x81\x10\x15a\x0ByW\x82\x82\x82\x81Q\x81\x10a\x0BFWa\x0BFa\x13^V[` \x02` \x01\x01Q`@Q` \x01a\x0B_\x92\x91\x90a\x13\xDDV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x0B\"V[PP\x93\x92PPPV[``a\x0B\x8E\x84\x84a\x12\x05V[`\x01`\x01`@\x1B\x03\x81\x11\x15a\x0B\xA5Wa\x0B\xA5a\x0F'V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0B\xD8W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x0B\xC3W\x90P[P\x90P\x83[\x83\x81\x10\x15a\x0COWa\x0C!\x86a\x0B\xF2\x83a\r\x1BV[\x85`@Q` \x01a\x0C\x05\x93\x92\x91\x90a\x13\xF1V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x02\x0C\x90a\x10\x8FV[\x82a\x0C,\x87\x84a\x12\x05V[\x81Q\x81\x10a\x0C^<#\x11a\x01\x1CW\x80cD\xBA\xDB\xB6\x11a\x01\x02W\x80cD\xBA\xDB\xB6\x14a\x01\xF4W\x80cR\x92\x13\xA1\x14a\x02\x14W\x80cf\xD9\xA9\xA0\x14a\x02\x1CW__\xFD[\x80c>^<#\x14a\x01\xE4W\x80c?r\x86\xF4\x14a\x01\xECW__\xFD[\x80c\x1C\r\xA8\x1F\x11a\x01LW\x80c\x1C\r\xA8\x1F\x14a\x01\x9AW\x80c\x1E\xD7\x83\x1C\x14a\x01\xBAW\x80c*\xDE8\x80\x14a\x01\xCFW__\xFD[\x80c\x08\x13\x85*\x14a\x01gW\x80c\x18\xCA\xF9\x16\x14a\x01\x90W[__\xFD[a\x01za\x01u6`\x04a\x1A\xB2V[a\x02\xBBV[`@Qa\x01\x87\x91\x90a\x1BgV[`@Q\x80\x91\x03\x90\xF3[a\x01\x98a\x03\x06V[\0[a\x01\xADa\x01\xA86`\x04a\x1A\xB2V[a\x04KV[`@Qa\x01\x87\x91\x90a\x1B\xCAV[a\x01\xC2a\x04\xBDV[`@Qa\x01\x87\x91\x90a\x1B\xDCV[a\x01\xD7a\x05\x1DV[`@Qa\x01\x87\x91\x90a\x1C\x81V[a\x01\xC2a\x06YV[a\x01\xC2a\x06\xB7V[a\x02\x07a\x02\x026`\x04a\x1A\xB2V[a\x07\x15V[`@Qa\x01\x87\x91\x90a\x1C\xF8V[a\x01\x98a\x07XV[a\x02$a\x08\\V[`@Qa\x01\x87\x91\x90a\x1D\x8BV[a\x029a\t\xD5V[`@Qa\x01\x87\x91\x90a\x1E\tV[a\x02Na\n\xA0V[`@Qa\x01\x87\x91\x90a\x1E\x1BV[a\x02Na\x0B\x96V[a\x029a\x0C\x8CV[a\x02sa\rWV[`@Q\x90\x15\x15\x81R` \x01a\x01\x87V[a\x01\x98a\x0E'V[a\x01\x98a\x0F\xD1V[a\x01\xC2a\x12\xD8V[`\x1FTa\x02s\x90`\xFF\x16\x81V[a\x02\x07a\x02\xB66`\x04a\x1A\xB2V[a\x136V[``a\x02\xFE\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x13yV[\x94\x93PPPPV[`@\x80Q\x80\x82\x01\x82R`\x13\x81R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x03\x87\x91\x90`\x04\x01a\x1B\xCAV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x03\x9EW__\xFD[PZ\xF1\x15\x80\x15a\x03\xB0W=__>=_\xFD[PP`\x1FT`&T`@Q\x7Ft\xC3\xA3\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\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x16\x93Pct\xC3\xA3\xA9\x92Pa\x04\x08\x91`%\x90`\n\x90`\x04\x01a\x1F\xB8V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04$W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04H\x91\x90a cV[PV[``_a\x04Y\x85\x85\x85a\x02\xBBV[\x90P_[a\x04g\x85\x85a \xB6V[\x81\x10\x15a\x04\xB4W\x82\x82\x82\x81Q\x81\x10a\x04\x81Wa\x04\x81a \xC9V[` \x02` \x01\x01Q`@Q` \x01a\x04\x9A\x92\x91\x90a!\rV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x04]V[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x05\x13W` \x02\x82\x01\x91\x90_R` _ \x90[\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04\xF5W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06PW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x069W\x83\x82\x90_R` _ \x01\x80Ta\x05\xAE\x90a\x1E\x92V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05\xDA\x90a\x1E\x92V[\x80\x15a\x06%W\x80`\x1F\x10a\x05\xFCWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x06%V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x06\x08W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x05\x91V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05@V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x05\x13W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04\xF5WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x05\x13W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04\xF5WPPPPP\x90P\x90V[``a\x02\xFE\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x14\xDAV[`@\x80Q\x80\x82\x01\x82R` \x80\x82R\x7FPassed in best is not best known\x90\x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x07\xD9\x91\x90`\x04\x01a\x1B\xCAV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07\xF0W__\xFD[PZ\xF1\x15\x80\x15a\x08\x02W=__>=_\xFD[PP`\x1FT`*T`@Q\x7Ft\xC3\xA3\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\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x16\x93Pct\xC3\xA3\xA9\x92Pa\x04\x08\x91`)\x90\x81\x90`\n\x90`\x04\x01a!!V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06PW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x08\xAF\x90a\x1E\x92V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x08\xDB\x90a\x1E\x92V[\x80\x15a\t&W\x80`\x1F\x10a\x08\xFDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\t&V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t\tW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\t\xBDW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\tjW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x08\x7FV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06PW\x83\x82\x90_R` _ \x01\x80Ta\n\x15\x90a\x1E\x92V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\nA\x90a\x1E\x92V[\x80\x15a\n\x8CW\x80`\x1F\x10a\ncWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\x8CV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\noW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\t\xF8V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06PW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0B~W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0B+W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\n\xC3V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06PW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0CtW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C!W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0B\xB9V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06PW\x83\x82\x90_R` _ \x01\x80Ta\x0C\xCC\x90a\x1E\x92V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C\xF8\x90a\x1E\x92V[\x80\x15a\rCW\x80`\x1F\x10a\r\x1AWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rCV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r&W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xAFV[`\x08T_\x90`\xFF\x16\x15a\rnWP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\r\xFCW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E \x91\x90a!]V[\x14\x15\x90P\x90V[`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16ct\xC3\xA3\xA9`&T`%`!_\x81T\x81\x10a\x0EcWa\x0Eca \xC9V[\x90_R` _ \x01`\n`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0E\x8C\x94\x93\x92\x91\x90a!!V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0E\xA8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\xCC\x91\x90a cV[Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\xF2\x8D\xCE\xB3`@Q\x80``\x01`@R\x80`)\x81R` \x01a#\x84`)\x919`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0F%\x91\x90a\x1B\xCAV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0F=_\xFD[PPPP`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16ct\xC3\xA3\xA9`&T`!_\x81T\x81\x10a\x0F\x8CWa\x0F\x8Ca \xC9V[\x90_R` _ \x01`!`\x01\x81T\x81\x10a\x0F\xA8Wa\x0F\xA8a \xC9V[\x90_R` _ \x01`\n`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x04\x08\x94\x93\x92\x91\x90a!!V[`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16ct\xC3\xA3\xA9`&T`%`!_\x81T\x81\x10a\x10\rWa\x10\ra \xC9V[\x90_R` _ \x01`\n`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x106\x94\x93\x92\x91\x90a!!V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10RW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10v\x91\x90a cV[Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16cD\x0E\xD1\r`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10\xC3W__\xFD[PZ\xF1\x15\x80\x15a\x10\xD5W=__>=_\xFD[PPPP`#_\x81T\x81\x10a\x10\xECWa\x10\xECa \xC9V[\x90_R` _ \x01T`(T`#_\x81T\x81\x10a\x11\x0BWa\x11\x0Ba \xC9V[_\x91\x82R` \x82 \x01T`@Q\x90\x91\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l\x91\xA4`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16ct\xC3\xA3\xA9`#_\x81T\x81\x10a\x11tWa\x11ta \xC9V[\x90_R` _ \x01T`!_\x81T\x81\x10a\x11\x90Wa\x11\x90a \xC9V[\x90_R` _ \x01`'`\x14`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x11\xBB\x94\x93\x92\x91\x90a!!V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11\xD7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\xFB\x91\x90a cV[Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\xF2\x8D\xCE\xB3`@Q\x80``\x01`@R\x80`3\x81R` \x01a#Q`3\x919`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x12T\x91\x90a\x1B\xCAV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12kW__\xFD[PZ\xF1\x15\x80\x15a\x12}W=__>=_\xFD[PPPP`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16ct\xC3\xA3\xA9`$`\x05\x81T\x81\x10a\x12\xB9Wa\x12\xB9a \xC9V[\x90_R` _ \x01T`'`\"`\x06\x81T\x81\x10a\x0F\xA8Wa\x0F\xA8a \xC9V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x05\x13W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04\xF5WPPPPP\x90P\x90V[``a\x02\xFE\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x16(V[``a\x13\x85\x84\x84a \xB6V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x13\x9DWa\x13\x9Da\x1A-V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x13\xD0W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x13\xBBW\x90P[P\x90P\x83[\x83\x81\x10\x15a\x14\xD1Wa\x14\xA3\x86a\x13\xEA\x83a\x17vV[\x85`@Q` \x01a\x13\xFD\x93\x92\x91\x90a!tV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x14\x19\x90a\x1E\x92V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x14E\x90a\x1E\x92V[\x80\x15a\x14\x90W\x80`\x1F\x10a\x14gWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x14\x90V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x14sW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x18\xA7\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x14\xAE\x87\x84a \xB6V[\x81Q\x81\x10a\x14\xBEWa\x14\xBEa \xC9V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x13\xD5V[P\x94\x93PPPPV[``a\x14\xE6\x84\x84a \xB6V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x14\xFEWa\x14\xFEa\x1A-V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x15'W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x14\xD1Wa\x15\xFA\x86a\x15A\x83a\x17vV[\x85`@Q` \x01a\x15T\x93\x92\x91\x90a!tV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x15p\x90a\x1E\x92V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x15\x9C\x90a\x1E\x92V[\x80\x15a\x15\xE7W\x80`\x1F\x10a\x15\xBEWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x15\xE7V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15\xCAW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x19F\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x16\x05\x87\x84a \xB6V[\x81Q\x81\x10a\x16\x15Wa\x16\x15a \xC9V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x15,V[``a\x164\x84\x84a \xB6V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16LWa\x16La\x1A-V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x16uW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x14\xD1Wa\x17H\x86a\x16\x8F\x83a\x17vV[\x85`@Q` \x01a\x16\xA2\x93\x92\x91\x90a!tV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x16\xBE\x90a\x1E\x92V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x16\xEA\x90a\x1E\x92V[\x80\x15a\x175W\x80`\x1F\x10a\x17\x0CWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x175V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x17\x18W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x19\xD9\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x17S\x87\x84a \xB6V[\x81Q\x81\x10a\x17cWa\x17ca \xC9V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x16zV[``\x81_\x03a\x17\xB8WPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x17\xE1W\x80a\x17\xCB\x81a\"\x11V[\x91Pa\x17\xDA\x90P`\n\x83a\"uV[\x91Pa\x17\xBBV[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17\xFBWa\x17\xFBa\x1A-V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x18%W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x02\xFEWa\x18:`\x01\x83a \xB6V[\x91Pa\x18G`\n\x86a\"\x88V[a\x18R\x90`0a\"\x9BV[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x18gWa\x18ga \xC9V[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x18\xA0`\n\x86a\"uV[\x94Pa\x18)V[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a\x18\xFC\x90\x86\x90\x86\x90`\x04\x01a\"\xAEV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x19\x16W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x19=\x91\x90\x81\x01\x90a\"\xDBV[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x19\x9A\x90\x86\x90\x86\x90`\x04\x01a\"\xAEV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x19\xB5W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x19=\x91\x90a!]V[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x19\x9A\x90\x86\x90\x86\x90`\x04\x01a\"\xAEV[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x1A\x83Wa\x1A\x83a\x1A-V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x1A\xA4Wa\x1A\xA4a\x1A-V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x1A\xC4W__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1A\xDAW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x1A\xEAW__\xFD[\x805a\x1A\xFDa\x1A\xF8\x82a\x1A\x8BV[a\x1AZV[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x1B\x11W__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1B\xBEW`?\x19\x87\x86\x03\x01\x84Ra\x1B\xA9\x85\x83Qa\x1B9V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1B\x8DV[P\x92\x96\x95PPPPPPV[` \x81R_a\x19=` \x83\x01\x84a\x1B9V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1C\x1CW\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1B\xF5V[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x1CuW`\x1F\x19\x85\x84\x03\x01\x88Ra\x1C_\x83\x83Qa\x1B9V[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x1CCV[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1B\xBEW`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1C\xE2`@\x87\x01\x82a\x1C'V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1C\xA7V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1C\x1CW\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1D\x11V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x1D\x81W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x1DAV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1B\xBEW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x1D\xD7`@\x88\x01\x82a\x1B9V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x1D\xF2\x81\x83a\x1D/V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1D\xB1V[` \x81R_a\x19=` \x83\x01\x84a\x1C'V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1B\xBEW`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1E|`@\x87\x01\x82a\x1D/V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1EAV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1E\xA6W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x1E\xDDW\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[P\x91\x90PV[\x80T_\x90`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1E\xFBW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x1F2W\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[\x81\x86R` \x86\x01\x81\x80\x15a\x1FMW`\x01\x81\x14a\x1F\x81Wa\x1F\xADV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x85\x16\x82R\x83\x15\x15`\x05\x1B\x82\x01\x95Pa\x1F\xADV[_\x87\x81R` \x90 _[\x85\x81\x10\x15a\x1F\xA7W\x81T\x84\x82\x01R`\x01\x90\x91\x01\x90` \x01a\x1F\x8BV[\x83\x01\x96PP[PPPPP\x92\x91PPV[\x83\x81R`\x80` \x82\x01R_a\x1F\xD0`\x80\x83\x01\x85a\x1E\xE3V[\x82\x81\x03`@\x84\x01R`P\x81R\x7F\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99` \x82\x01R\x7F\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99`@\x82\x01R\x7F\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0``\x82\x01R`\x80\x81\x01\x91PP\x82``\x83\x01R\x94\x93PPPPV[_` \x82\x84\x03\x12\x15a sW__\xFD[\x81Q\x80\x15\x15\x81\x14a \x82W__\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`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x19@Wa\x19@a \x89V[\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x02\xFEa!\x1B\x83\x86a \xF6V[\x84a \xF6V[\x84\x81R`\x80` \x82\x01R_a!9`\x80\x83\x01\x86a\x1E\xE3V[\x82\x81\x03`@\x84\x01Ra!K\x81\x86a\x1E\xE3V[\x91PP\x82``\x83\x01R\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a!mW__\xFD[PQ\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\x81R_a!\xA5`\x01\x83\x01\x86a \xF6V[\x7F[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra!\xD5`\x01\x82\x01\x86a \xF6V[\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\x81Ra\"\x07`\x02\x82\x01\x85a \xF6V[\x96\x95PPPPPPV[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\"AWa\"Aa \x89V[P`\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`\x12`\x04R`$_\xFD[_\x82a\"\x83Wa\"\x83a\"HV[P\x04\x90V[_\x82a\"\x96Wa\"\x96a\"HV[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a\x19@Wa\x19@a \x89V[`@\x81R_a\"\xC0`@\x83\x01\x85a\x1B9V[\x82\x81\x03` \x84\x01Ra\"\xD2\x81\x85a\x1B9V[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\"\xEBW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a#\x01W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a#\x11W__\xFD[\x80Qa#\x1Fa\x1A\xF8\x82a\x1A\x8BV[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a#3W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV\xFENew best hash does not have more work than previousAncestor must be heaviest common ancestor\xA2dipfsX\"\x12 {\xB6\xBD\xEC'\xCF\x89Ix,\xEC5u\xAD\x995B\xD7\xA6\xE6\xF8\xE9 M\xF5\xA03\xB3l\x8F\xDCodsolcC\0\x08\x1C\x003`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa);8\x03\x80a);\x839\x81\x01`@\x81\x90Ra\0.\x91a\x03+V[\x82\x82\x82\x82\x82\x82a\0?\x83Q`P\x14\x90V[a\0\x84W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x11`$\x82\x01RpBad genesis block`x\x1B`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\0\x8E\x84a\x01fV[\x90Pb\xFF\xFF\xFF\x82\x16\x15a\x01\tW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FPeriod start hash does not have `D\x82\x01R\x7Fwork. Hint: wrong byte order?\0\0\0`d\x82\x01R`\x84\x01a\0{V[_\x81\x81U`\x01\x82\x90U`\x02\x82\x90U\x81\x81R`\x04` R`@\x90 \x83\x90Ua\x012a\x07\xE0\x84a\x03\xFEV[a\x01<\x90\x84a\x04%V[_\x83\x81R`\x04` R`@\x90 Ua\x01S\x84a\x02&V[`\x05UPa\x05\xBD\x98PPPPPPPPPV[_`\x02\x80\x83`@Qa\x01x\x91\x90a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\x93W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x04NV[`@Q` \x01a\x01\xC8\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x01\xE2\x91a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\xFDW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02 \x91\x90a\x04NV[\x92\x91PPV[_a\x02 a\x023\x83a\x028V[a\x02CV[_a\x02 \x82\x82a\x02SV[_a\x02 a\xFF\xFF`\xD0\x1B\x83a\x02\xF7V[_\x80a\x02ja\x02c\x84`Ha\x04eV[\x85\x90a\x03\tV[`\xE8\x1C\x90P_\x84a\x02|\x85`Ka\x04eV[\x81Q\x81\x10a\x02\x8CWa\x02\x8Ca\x04xV[\x01` \x01Q`\xF8\x1C\x90P_a\x02\xBE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x02\xD1`\x03\x84a\x04\x8CV[`\xFF\x16\x90Pa\x02\xE2\x81a\x01\0a\x05\x88V[a\x02\xEC\x90\x83a\x05\x93V[\x97\x96PPPPPPPV[_a\x03\x02\x82\x84a\x05\xAAV[\x93\x92PPPV[_a\x03\x02\x83\x83\x01` \x01Q\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x03=W__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03RW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03bW__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03{Wa\x03{a\x03\x17V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x03\xA9Wa\x03\xA9a\x03\x17V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x03\xC0W__\xFD[\x81` \x84\x01` \x83\x01^_` \x92\x82\x01\x83\x01R\x90\x86\x01Q`@\x90\x96\x01Q\x90\x97\x95\x96P\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x04\x0CWa\x04\x0Ca\x03\xEAV[P\x06\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x04^W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02 Wa\x02 a\x04\x11V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[`\x01\x81[`\x01\x84\x11\x15a\x04\xE0W\x80\x85\x04\x81\x11\x15a\x04\xC4Wa\x04\xC4a\x04\x11V[`\x01\x84\x16\x15a\x04\xD2W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x04\xA9V[\x93P\x93\x91PPV[_\x82a\x04\xF6WP`\x01a\x02 V[\x81a\x05\x02WP_a\x02 V[\x81`\x01\x81\x14a\x05\x18W`\x02\x81\x14a\x05\"Wa\x05>V[`\x01\x91PPa\x02 V[`\xFF\x84\x11\x15a\x053Wa\x053a\x04\x11V[PP`\x01\x82\x1Ba\x02 V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x05aWP\x81\x81\na\x02 V[a\x05m_\x19\x84\x84a\x04\xA5V[\x80_\x19\x04\x82\x11\x15a\x05\x80Wa\x05\x80a\x04\x11V[\x02\x93\x92PPPV[_a\x03\x02\x83\x83a\x04\xE8V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x02 Wa\x02 a\x04\x11V[_\x82a\x05\xB8Wa\x05\xB8a\x03\xEAV[P\x04\x90V[a#q\x80a\x05\xCA_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\xADW\x80c\xB9\x85b\x1A\x11a\0}W\x80c\xE3\xD8\xD8\xD8\x11a\0cW\x80c\xE3\xD8\xD8\xD8\x14a\x02\"W\x80c\xE4q\xE7,\x14a\x02)W\x80c\xF5\x8D\xB0o\x14a\x02=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x13\x91\x90a!WV[`@Q` \x01a\x0C%\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\x90\x82\x90Ra\x0C]\x91a!AV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0CxW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x07\x91\x90a!WV[_\x83\x85\x14\x80\x15a\x0C\xAAWP\x82\x85\x14[\x15a\x0C\xB7WP`\x01a\x04\xF1V[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x0C\xFFW\x89\x83\x14a\x0C\xDEW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x0C\xF7W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x0C\xBDV[P\x82\x84\x03a\r\x13W_\x94PPPPPa\x04\xF1V[\x80\x82\x14a\r&W_\x94PPPPPa\x04\xF1V[P`\x01\x98\x97PPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\rYW_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\r9V[P\x80a\x05\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x80\x82\x81[a\r\xB8`\x04`\x01a!\x9BV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0E\x0CW_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\r\xF1W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0E\x04V[a\r\xFB\x81\x84a!\xB7V[\x95\x94PPPPPV[`\x01\x01a\r\xACV[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_`P\x82Qa\x0B~\x91\x90a!.V[__a\x0Eo\x85a\x0B\xC3V[\x90P_a\x0E{\x82a\r\xA7V[\x90P_a\x0E\x87\x86a\x19\xE6V[\x90P\x84\x80a\x0E\x9CWP\x80a\x0E\x9A\x88a\x19\xE6V[\x14[a\x0F\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x03.V[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x12\x0EWa\x0F(`P\x82a!\xCAV[a\x0F3\x90`\x01a!\xB7V[a\x0F=\x90\x87a!\xB7V[\x93Pa\x0FK\x8A\x82`Pa\x19\xF1V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x11!W\x84a\x10\xA1\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x10\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x11\n`\x04\x85a!.V[_\x03a\x11!W_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x11,\x8B\x83a\x1A\x16V[\x14a\x11yW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[\x86a\x11\x84\x8B\x83a\x1A\xAFV[\x14a\x11\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x03.V[\x82\x96P`P\x81a\x12\x07\x91\x90a!\xB7V[\x90Pa\x0F\x15V[P\x81a\x12\x19\x8Ba\x0B\xC3V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x12\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x12\xD4\x84a\x0B\xC3V[\x90P_a\x12\xE0\x86a\x0B\xC3V[\x90P`\x01T\x81\x14a\x133W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x03.V[_\x82\x81R`\x03` R`@\x90 Ta\x13\x8DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x13\x9B\x87`\x01T\x84\x87a\x0C\x9BV[a\x14\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x03.V[\x81a\x14\x19\x88\x88\x88a\x17\x80V[\x14a\x14\x8CW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[`\x01\x82\x90U`\x02\x87\x90U_a\x14\xA0\x86a\x1A\xC7V[\x90P`\x05T\x81\x14a\x14\xB1W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x15\x01a\x14\xFC\x86a\x0B\xC3V[a\r\xA7V[\x90P_a\x15\x10a\x14\xFC\x86a\x0B\xC3V[\x90Pa\x15\x1Ea\x07\xE0\x82a!.V[a\x07\xDF\x14a\x15\x94W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x03.V[a\x15\xA0\x82a\x07\xDFa!\xB7V[\x81\x14a\x16\x14W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x03.V[a\x16\x1D\x85a\x1A\xC7V[a\x16&\x87a\x1A\xC7V[\x14a\x16\x99W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x03.V[_a\x16\xA3\x85a\x19\xE6V[\x90P_a\x16\xD5a\x16\xB2\x89a\x19\xE6V[a\x16\xBB\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x16\xCA\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x1B\x0CV[\x90P\x81\x81\x83\x16\x14a\x17(W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_a\x172\x89a\x1A\xC7V[\x90P\x80`\x06T\x14\x15\x80\x15a\x17\\WPa\x07\xE0a\x17O`\x01Ta\r\xA7V[a\x17Y\x91\x90a!\xDDV[\x84\x11[\x15a\x17gW`\x06\x81\x90U[a\x17s\x88\x88`\x01a\x0EdV[\x99\x98PPPPPPPPPV[__a\x17\x8B\x85a\r\xA7V[\x90P_a\x17\x9Aa\x14\xFC\x86a\x0B\xC3V[\x90P_a\x17\xA9a\x14\xFC\x86a\x0B\xC3V[\x90P\x82\x82\x10\x15\x80\x15a\x17\xBBWP\x82\x81\x10\x15[a\x18-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x18:a\x07\xE0\x85a!.V[a\x18F\x85a\x07\xE0a!\xB7V[a\x18P\x91\x90a!\xDDV[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x18bWP\x80[\x15a\x18}Wa\x18p\x89a\x0B\xC3V[\x96PPPPPPPa\n\xA3V[\x81\x80\x15a\x18\x88WP\x80\x15[\x15a\x18\x96Wa\x18p\x88a\x0B\xC3V[\x81\x80\x15a\x18\xA0WP\x80[\x15a\x18\xC4W\x83\x85\x10\x15a\x18\xBBWa\x18\xB6\x88a\x0B\xC3V[a\x18pV[a\x18p\x89a\x0B\xC3V[a\x18\xCD\x88a\x1A\xC7V[a\x18\xD9a\x07\xE0\x86a!.V[a\x18\xE3\x91\x90a!\xF0V[a\x18\xEC\x8Aa\x1A\xC7V[a\x18\xF8a\x07\xE0\x88a!.V[a\x19\x02\x91\x90a!\xF0V[\x10\x15a\x18\xBBWa\x18p\x88a\x0B\xC3V[`\x07T_\x90`\xFF\x16\x15a\x19/WP`\x07Ta\x01\0\x90\x04`\xFF\x16a\n\xA3V[a\x19:\x84\x84\x84a\x1B\x94V[\x90Pa\n\xA3V[_` \x84Qa\x19P\x91\x90a!.V[\x15a\x19\\WP_a\x04\xF1V[\x83Q_\x03a\x19kWP_a\x04\xF1V[\x81\x85_[\x86Q\x81\x10\x15a\x19\xD9Wa\x19\x83`\x02\x84a!.V[`\x01\x03a\x19\xA7Wa\x19\xA0a\x19\x9A\x88\x83\x01` \x01Q\x90V[\x83a\x1B\xD5V[\x91Pa\x19\xC0V[a\x19\xBD\x82a\x19\xB8\x89\x84\x01` \x01Q\x90V[a\x1B\xD5V[\x91P[`\x01\x92\x90\x92\x1C\x91a\x19\xD2` \x82a!\xB7V[\x90Pa\x19oV[P\x90\x93\x14\x95\x94PPPPPV[_a\x05\x07\x82_a\x1A\x16V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x1A-a\x1A&\x84`Ha!\xB7V[\x85\x90a\x1B\xE0V[`\xE8\x1C\x90P_\x84a\x1A?\x85`Ka!\xB7V[\x81Q\x81\x10a\x1AOWa\x1AOa\"\x07V[\x01` \x01Q`\xF8\x1C\x90P_a\x1A\x81\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1A\x94`\x03\x84a\"4V[`\xFF\x16\x90Pa\x1A\xA5\x81a\x01\0a#0V[a\x08-\x90\x83a!\xF0V[_a\x05\x04a\x1A\xBE\x83`\x04a!\xB7V[\x84\x01` \x01Q\x90V[_a\x05\x07a\x1A\xD4\x83a\x19\xE6V[a\x1B\xEEV[_a\x05\x07a\x1A\xE6\x83a\x1C\x15V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1B\x18\x83\x85a\x1C!V[\x90Pa\x1B(b\x12u\0`\x04a\x1C|V[\x81\x10\x15a\x1B@Wa\x1B=b\x12u\0`\x04a\x1C|V[\x90P[a\x1BNb\x12u\0`\x04a\x1C\x87V[\x81\x11\x15a\x1BfWa\x1Bcb\x12u\0`\x04a\x1C\x87V[\x90P[_a\x1B~\x82a\x1Bx\x88b\x01\0\0a\x1C|V[\x90a\x1C\x87V[\x90Pa\n\x8Ab\x01\0\0a\x1Bx\x83b\x12u\0a\x1C|V[_\x82\x81[\x83\x81\x10\x15a\x1B\xCAW\x85\x82\x03a\x1B\xB2W`\x01\x92PPPa\n\xA3V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x1B\x98V[P_\x95\x94PPPPPV[_a\x05\x04\x83\x83a\x1C\xFAV[_a\x05\x04\x83\x83\x01` \x01Q\x90V[_a\x05\x07{\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\x83a\x1C|V[_a\x05\x07\x82`Da\x1B\xE0V[_\x82\x82\x11\x15a\x1CrW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x05\x04\x82\x84a!\xDDV[_a\x05\x04\x82\x84a!\xCAV[_\x82_\x03a\x1C\x96WP_a\x05\x07V[a\x1C\xA0\x82\x84a!\xF0V[\x90P\x81a\x1C\xAD\x84\x83a!\xCAV[\x14a\x05\x07W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x03.V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1D1W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DHW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1D_W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1DvW__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1D\x91W__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xA7W__\xFD[a\x1D\xB3\x8A\x82\x8B\x01a\x1D!V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xD2W__\xFD[a\x1D\xDE\x8A\x82\x8B\x01a\x1D!V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1D\xFE`\x80\x89\x01a\x1DfV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[____`\x80\x85\x87\x03\x12\x15a\x1E\x1FW__\xFD[PP\x825\x94` \x84\x015\x94P`@\x84\x015\x93``\x015\x92P\x90PV[__`@\x83\x85\x03\x12\x15a\x1ELW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1EkW__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1E\x85W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x9BW__\xFD[a\x1E\xA7\x87\x82\x88\x01a\x1D!V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\xC6W__\xFD[a\x1E\xD2\x87\x82\x88\x01a\x1D!V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1E\xF3W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x10W__\xFD[a\x1F\x1C\x89\x82\x8A\x01a\x1D!V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F;W__\xFD[a\x1FG\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1FtW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x8AW__\xFD[a\x1F\x96\x89\x82\x8A\x01a\x1D!V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xB5W__\xFD[a\x1F\xC1\x89\x82\x8A\x01a\x1D!V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xE0W__\xFD[a\x1F\xEC\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_____``\x86\x88\x03\x12\x15a \x12W__\xFD[\x855\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a /W__\xFD[a ;\x88\x82\x89\x01a\x1D!V[\x90\x95P\x93PP`@\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a ZW__\xFD[a f\x88\x82\x89\x01a\x1D!V[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[___``\x84\x86\x03\x12\x15a \x89W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a \xB1W__\xFD[\x825\x91Pa \xC1` \x84\x01a\x1DfV[\x90P\x92P\x92\x90PV[\x805\x80\x15\x15\x81\x14a\x1DvW__\xFD[__`@\x83\x85\x03\x12\x15a \xEAW__\xFD[a \xF3\x83a \xCAV[\x91Pa \xC1` \x84\x01a \xCAV[\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!^<#\x11a\x01\x1CW\x80cD\xBA\xDB\xB6\x11a\x01\x02W\x80cD\xBA\xDB\xB6\x14a\x01\xF4W\x80cR\x92\x13\xA1\x14a\x02\x14W\x80cf\xD9\xA9\xA0\x14a\x02\x1CW__\xFD[\x80c>^<#\x14a\x01\xE4W\x80c?r\x86\xF4\x14a\x01\xECW__\xFD[\x80c\x1C\r\xA8\x1F\x11a\x01LW\x80c\x1C\r\xA8\x1F\x14a\x01\x9AW\x80c\x1E\xD7\x83\x1C\x14a\x01\xBAW\x80c*\xDE8\x80\x14a\x01\xCFW__\xFD[\x80c\x08\x13\x85*\x14a\x01gW\x80c\x18\xCA\xF9\x16\x14a\x01\x90W[__\xFD[a\x01za\x01u6`\x04a\x1A\xB2V[a\x02\xBBV[`@Qa\x01\x87\x91\x90a\x1BgV[`@Q\x80\x91\x03\x90\xF3[a\x01\x98a\x03\x06V[\0[a\x01\xADa\x01\xA86`\x04a\x1A\xB2V[a\x04KV[`@Qa\x01\x87\x91\x90a\x1B\xCAV[a\x01\xC2a\x04\xBDV[`@Qa\x01\x87\x91\x90a\x1B\xDCV[a\x01\xD7a\x05\x1DV[`@Qa\x01\x87\x91\x90a\x1C\x81V[a\x01\xC2a\x06YV[a\x01\xC2a\x06\xB7V[a\x02\x07a\x02\x026`\x04a\x1A\xB2V[a\x07\x15V[`@Qa\x01\x87\x91\x90a\x1C\xF8V[a\x01\x98a\x07XV[a\x02$a\x08\\V[`@Qa\x01\x87\x91\x90a\x1D\x8BV[a\x029a\t\xD5V[`@Qa\x01\x87\x91\x90a\x1E\tV[a\x02Na\n\xA0V[`@Qa\x01\x87\x91\x90a\x1E\x1BV[a\x02Na\x0B\x96V[a\x029a\x0C\x8CV[a\x02sa\rWV[`@Q\x90\x15\x15\x81R` \x01a\x01\x87V[a\x01\x98a\x0E'V[a\x01\x98a\x0F\xD1V[a\x01\xC2a\x12\xD8V[`\x1FTa\x02s\x90`\xFF\x16\x81V[a\x02\x07a\x02\xB66`\x04a\x1A\xB2V[a\x136V[``a\x02\xFE\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x13yV[\x94\x93PPPPV[`@\x80Q\x80\x82\x01\x82R`\x13\x81R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x03\x87\x91\x90`\x04\x01a\x1B\xCAV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x03\x9EW__\xFD[PZ\xF1\x15\x80\x15a\x03\xB0W=__>=_\xFD[PP`\x1FT`&T`@Q\x7Ft\xC3\xA3\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\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x16\x93Pct\xC3\xA3\xA9\x92Pa\x04\x08\x91`%\x90`\n\x90`\x04\x01a\x1F\xB8V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04$W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04H\x91\x90a cV[PV[``_a\x04Y\x85\x85\x85a\x02\xBBV[\x90P_[a\x04g\x85\x85a \xB6V[\x81\x10\x15a\x04\xB4W\x82\x82\x82\x81Q\x81\x10a\x04\x81Wa\x04\x81a \xC9V[` \x02` \x01\x01Q`@Q` \x01a\x04\x9A\x92\x91\x90a!\rV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x04]V[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x05\x13W` \x02\x82\x01\x91\x90_R` _ \x90[\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04\xF5W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06PW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x069W\x83\x82\x90_R` _ \x01\x80Ta\x05\xAE\x90a\x1E\x92V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05\xDA\x90a\x1E\x92V[\x80\x15a\x06%W\x80`\x1F\x10a\x05\xFCWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x06%V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x06\x08W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x05\x91V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05@V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x05\x13W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04\xF5WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x05\x13W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04\xF5WPPPPP\x90P\x90V[``a\x02\xFE\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x14\xDAV[`@\x80Q\x80\x82\x01\x82R` \x80\x82R\x7FPassed in best is not best known\x90\x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x07\xD9\x91\x90`\x04\x01a\x1B\xCAV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07\xF0W__\xFD[PZ\xF1\x15\x80\x15a\x08\x02W=__>=_\xFD[PP`\x1FT`*T`@Q\x7Ft\xC3\xA3\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\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x16\x93Pct\xC3\xA3\xA9\x92Pa\x04\x08\x91`)\x90\x81\x90`\n\x90`\x04\x01a!!V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06PW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x08\xAF\x90a\x1E\x92V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x08\xDB\x90a\x1E\x92V[\x80\x15a\t&W\x80`\x1F\x10a\x08\xFDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\t&V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t\tW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\t\xBDW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\tjW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x08\x7FV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06PW\x83\x82\x90_R` _ \x01\x80Ta\n\x15\x90a\x1E\x92V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\nA\x90a\x1E\x92V[\x80\x15a\n\x8CW\x80`\x1F\x10a\ncWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\x8CV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\noW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\t\xF8V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06PW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0B~W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0B+W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\n\xC3V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06PW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0CtW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C!W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0B\xB9V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06PW\x83\x82\x90_R` _ \x01\x80Ta\x0C\xCC\x90a\x1E\x92V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C\xF8\x90a\x1E\x92V[\x80\x15a\rCW\x80`\x1F\x10a\r\x1AWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rCV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r&W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xAFV[`\x08T_\x90`\xFF\x16\x15a\rnWP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\r\xFCW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E \x91\x90a!]V[\x14\x15\x90P\x90V[`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16ct\xC3\xA3\xA9`&T`%`!_\x81T\x81\x10a\x0EcWa\x0Eca \xC9V[\x90_R` _ \x01`\n`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0E\x8C\x94\x93\x92\x91\x90a!!V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0E\xA8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\xCC\x91\x90a cV[Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\xF2\x8D\xCE\xB3`@Q\x80``\x01`@R\x80`)\x81R` \x01a#\x84`)\x919`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0F%\x91\x90a\x1B\xCAV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0F=_\xFD[PPPP`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16ct\xC3\xA3\xA9`&T`!_\x81T\x81\x10a\x0F\x8CWa\x0F\x8Ca \xC9V[\x90_R` _ \x01`!`\x01\x81T\x81\x10a\x0F\xA8Wa\x0F\xA8a \xC9V[\x90_R` _ \x01`\n`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x04\x08\x94\x93\x92\x91\x90a!!V[`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16ct\xC3\xA3\xA9`&T`%`!_\x81T\x81\x10a\x10\rWa\x10\ra \xC9V[\x90_R` _ \x01`\n`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x106\x94\x93\x92\x91\x90a!!V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10RW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10v\x91\x90a cV[Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16cD\x0E\xD1\r`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10\xC3W__\xFD[PZ\xF1\x15\x80\x15a\x10\xD5W=__>=_\xFD[PPPP`#_\x81T\x81\x10a\x10\xECWa\x10\xECa \xC9V[\x90_R` _ \x01T`(T`#_\x81T\x81\x10a\x11\x0BWa\x11\x0Ba \xC9V[_\x91\x82R` \x82 \x01T`@Q\x90\x91\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l\x91\xA4`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16ct\xC3\xA3\xA9`#_\x81T\x81\x10a\x11tWa\x11ta \xC9V[\x90_R` _ \x01T`!_\x81T\x81\x10a\x11\x90Wa\x11\x90a \xC9V[\x90_R` _ \x01`'`\x14`@Q\x85c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x11\xBB\x94\x93\x92\x91\x90a!!V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11\xD7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\xFB\x91\x90a cV[Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\xF2\x8D\xCE\xB3`@Q\x80``\x01`@R\x80`3\x81R` \x01a#Q`3\x919`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x12T\x91\x90a\x1B\xCAV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12kW__\xFD[PZ\xF1\x15\x80\x15a\x12}W=__>=_\xFD[PPPP`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16ct\xC3\xA3\xA9`$`\x05\x81T\x81\x10a\x12\xB9Wa\x12\xB9a \xC9V[\x90_R` _ \x01T`'`\"`\x06\x81T\x81\x10a\x0F\xA8Wa\x0F\xA8a \xC9V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x05\x13W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04\xF5WPPPPP\x90P\x90V[``a\x02\xFE\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x16(V[``a\x13\x85\x84\x84a \xB6V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x13\x9DWa\x13\x9Da\x1A-V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x13\xD0W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x13\xBBW\x90P[P\x90P\x83[\x83\x81\x10\x15a\x14\xD1Wa\x14\xA3\x86a\x13\xEA\x83a\x17vV[\x85`@Q` \x01a\x13\xFD\x93\x92\x91\x90a!tV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x14\x19\x90a\x1E\x92V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x14E\x90a\x1E\x92V[\x80\x15a\x14\x90W\x80`\x1F\x10a\x14gWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x14\x90V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x14sW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x18\xA7\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x14\xAE\x87\x84a \xB6V[\x81Q\x81\x10a\x14\xBEWa\x14\xBEa \xC9V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x13\xD5V[P\x94\x93PPPPV[``a\x14\xE6\x84\x84a \xB6V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x14\xFEWa\x14\xFEa\x1A-V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x15'W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x14\xD1Wa\x15\xFA\x86a\x15A\x83a\x17vV[\x85`@Q` \x01a\x15T\x93\x92\x91\x90a!tV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x15p\x90a\x1E\x92V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x15\x9C\x90a\x1E\x92V[\x80\x15a\x15\xE7W\x80`\x1F\x10a\x15\xBEWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x15\xE7V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15\xCAW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x19F\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x16\x05\x87\x84a \xB6V[\x81Q\x81\x10a\x16\x15Wa\x16\x15a \xC9V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x15,V[``a\x164\x84\x84a \xB6V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16LWa\x16La\x1A-V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x16uW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x14\xD1Wa\x17H\x86a\x16\x8F\x83a\x17vV[\x85`@Q` \x01a\x16\xA2\x93\x92\x91\x90a!tV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x16\xBE\x90a\x1E\x92V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x16\xEA\x90a\x1E\x92V[\x80\x15a\x175W\x80`\x1F\x10a\x17\x0CWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x175V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x17\x18W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x19\xD9\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x17S\x87\x84a \xB6V[\x81Q\x81\x10a\x17cWa\x17ca \xC9V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x16zV[``\x81_\x03a\x17\xB8WPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x17\xE1W\x80a\x17\xCB\x81a\"\x11V[\x91Pa\x17\xDA\x90P`\n\x83a\"uV[\x91Pa\x17\xBBV[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17\xFBWa\x17\xFBa\x1A-V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x18%W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x02\xFEWa\x18:`\x01\x83a \xB6V[\x91Pa\x18G`\n\x86a\"\x88V[a\x18R\x90`0a\"\x9BV[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x18gWa\x18ga \xC9V[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x18\xA0`\n\x86a\"uV[\x94Pa\x18)V[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a\x18\xFC\x90\x86\x90\x86\x90`\x04\x01a\"\xAEV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x19\x16W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x19=\x91\x90\x81\x01\x90a\"\xDBV[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x19\x9A\x90\x86\x90\x86\x90`\x04\x01a\"\xAEV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x19\xB5W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x19=\x91\x90a!]V[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x19\x9A\x90\x86\x90\x86\x90`\x04\x01a\"\xAEV[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x1A\x83Wa\x1A\x83a\x1A-V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x1A\xA4Wa\x1A\xA4a\x1A-V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x1A\xC4W__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1A\xDAW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x1A\xEAW__\xFD[\x805a\x1A\xFDa\x1A\xF8\x82a\x1A\x8BV[a\x1AZV[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x1B\x11W__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1B\xBEW`?\x19\x87\x86\x03\x01\x84Ra\x1B\xA9\x85\x83Qa\x1B9V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1B\x8DV[P\x92\x96\x95PPPPPPV[` \x81R_a\x19=` \x83\x01\x84a\x1B9V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1C\x1CW\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1B\xF5V[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x1CuW`\x1F\x19\x85\x84\x03\x01\x88Ra\x1C_\x83\x83Qa\x1B9V[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x1CCV[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1B\xBEW`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1C\xE2`@\x87\x01\x82a\x1C'V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1C\xA7V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1C\x1CW\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1D\x11V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x1D\x81W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x1DAV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1B\xBEW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x1D\xD7`@\x88\x01\x82a\x1B9V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x1D\xF2\x81\x83a\x1D/V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1D\xB1V[` \x81R_a\x19=` \x83\x01\x84a\x1C'V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1B\xBEW`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1E|`@\x87\x01\x82a\x1D/V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1EAV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1E\xA6W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x1E\xDDW\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[P\x91\x90PV[\x80T_\x90`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1E\xFBW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x1F2W\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[\x81\x86R` \x86\x01\x81\x80\x15a\x1FMW`\x01\x81\x14a\x1F\x81Wa\x1F\xADV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x85\x16\x82R\x83\x15\x15`\x05\x1B\x82\x01\x95Pa\x1F\xADV[_\x87\x81R` \x90 _[\x85\x81\x10\x15a\x1F\xA7W\x81T\x84\x82\x01R`\x01\x90\x91\x01\x90` \x01a\x1F\x8BV[\x83\x01\x96PP[PPPPP\x92\x91PPV[\x83\x81R`\x80` \x82\x01R_a\x1F\xD0`\x80\x83\x01\x85a\x1E\xE3V[\x82\x81\x03`@\x84\x01R`P\x81R\x7F\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99` \x82\x01R\x7F\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99`@\x82\x01R\x7F\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0``\x82\x01R`\x80\x81\x01\x91PP\x82``\x83\x01R\x94\x93PPPPV[_` \x82\x84\x03\x12\x15a sW__\xFD[\x81Q\x80\x15\x15\x81\x14a \x82W__\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`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x19@Wa\x19@a \x89V[\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x02\xFEa!\x1B\x83\x86a \xF6V[\x84a \xF6V[\x84\x81R`\x80` \x82\x01R_a!9`\x80\x83\x01\x86a\x1E\xE3V[\x82\x81\x03`@\x84\x01Ra!K\x81\x86a\x1E\xE3V[\x91PP\x82``\x83\x01R\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a!mW__\xFD[PQ\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\x81R_a!\xA5`\x01\x83\x01\x86a \xF6V[\x7F[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra!\xD5`\x01\x82\x01\x86a \xF6V[\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\x81Ra\"\x07`\x02\x82\x01\x85a \xF6V[\x96\x95PPPPPPV[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\"AWa\"Aa \x89V[P`\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`\x12`\x04R`$_\xFD[_\x82a\"\x83Wa\"\x83a\"HV[P\x04\x90V[_\x82a\"\x96Wa\"\x96a\"HV[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a\x19@Wa\x19@a \x89V[`@\x81R_a\"\xC0`@\x83\x01\x85a\x1B9V[\x82\x81\x03` \x84\x01Ra\"\xD2\x81\x85a\x1B9V[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\"\xEBW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a#\x01W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a#\x11W__\xFD[\x80Qa#\x1Fa\x1A\xF8\x82a\x1A\x8BV[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a#3W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV\xFENew best hash does not have more work than previousAncestor must be heaviest common ancestor\xA2dipfsX\"\x12 {\xB6\xBD\xEC'\xCF\x89Ix,\xEC5u\xAD\x995B\xD7\xA6\xE6\xF8\xE9 M\xF5\xA03\xB3l\x8F\xDCodsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `NewTip(bytes32,bytes32,bytes32)` and selector `0x3cc13de64df0f0239626235c51a2da251bbc8c85664ecce39263da3ee03f606c`. -```solidity -event NewTip(bytes32 indexed _from, bytes32 indexed _to, bytes32 indexed _gcd); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct NewTip { - #[allow(missing_docs)] - pub _from: alloy::sol_types::private::FixedBytes<32>, - #[allow(missing_docs)] - pub _to: alloy::sol_types::private::FixedBytes<32>, - #[allow(missing_docs)] - pub _gcd: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for NewTip { - type DataTuple<'a> = (); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'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 SIGNATURE: &'static str = "NewTip(bytes32,bytes32,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 60u8, 193u8, 61u8, 230u8, 77u8, 240u8, 240u8, 35u8, 150u8, 38u8, 35u8, - 92u8, 81u8, 162u8, 218u8, 37u8, 27u8, 188u8, 140u8, 133u8, 102u8, 78u8, - 204u8, 227u8, 146u8, 99u8, 218u8, 62u8, 224u8, 63u8, 96u8, 108u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - _from: topics.1, - _to: topics.2, - _gcd: topics.3, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return 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) -> ::RustType { - ( - Self::SIGNATURE_HASH.into(), - self._from.clone(), - self._to.clone(), - self._gcd.clone(), - ) - } - #[inline] - fn encode_topics_raw( - &self, - out: &mut [alloy_sol_types::abi::token::WordToken], - ) -> alloy_sol_types::Result<()> { - if out.len() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self._from); - out[2usize] = as alloy_sol_types::EventTopic>::encode_topic(&self._to); - out[3usize] = as alloy_sol_types::EventTopic>::encode_topic(&self._gcd); - Ok(()) - } - } - #[automatically_derived] - impl alloy_sol_types::private::IntoLogData for NewTip { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&NewTip> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &NewTip) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. -```solidity -event log(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolConstructor for constructorCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getBlockHeights(string,uint256,uint256)` and selector `0xfad06b8f`. -```solidity -function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getBlockHeightsCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getBlockHeights(string,uint256,uint256)`](getBlockHeightsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getBlockHeightsReturn { - #[allow(missing_docs)] - pub elements: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getBlockHeightsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - #[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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getBlockHeightsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getBlockHeightsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getBlockHeights(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [250u8, 208u8, 107u8, 143u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getDigestLes(string,uint256,uint256)` and selector `0x44badbb6`. -```solidity -function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getDigestLesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getDigestLes(string,uint256,uint256)`](getDigestLesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getDigestLesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getDigestLesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getDigestLesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getDigestLesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array< - alloy::sol_types::sol_data::FixedBytes<32>, - >, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getDigestLes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [68u8, 186u8, 219u8, 182u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaderHexes(string,uint256,uint256)` and selector `0x0813852a`. -```solidity -function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaderHexes(string,uint256,uint256)`](getHeaderHexesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeaderHexesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getHeaderHexesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getHeaderHexesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Bytes, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaderHexes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [8u8, 19u8, 133u8, 42u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaders(string,uint256,uint256)` and selector `0x1c0da81f`. -```solidity -function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaders(string,uint256,uint256)`](getHeadersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersReturn { - #[allow(missing_docs)] - pub headers: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersReturn) -> Self { - (value.headers,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { headers: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getHeadersCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Bytes; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaders(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [28u8, 13u8, 168u8, 31u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testPassedInAncestorNotTheHeaviestCommon()` and selector `0xbb8acbf0`. -```solidity -function testPassedInAncestorNotTheHeaviestCommon() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testPassedInAncestorNotTheHeaviestCommonCall; - ///Container type for the return parameters of the [`testPassedInAncestorNotTheHeaviestCommon()`](testPassedInAncestorNotTheHeaviestCommonCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testPassedInAncestorNotTheHeaviestCommonReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testPassedInAncestorNotTheHeaviestCommonCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testPassedInAncestorNotTheHeaviestCommonCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testPassedInAncestorNotTheHeaviestCommonReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testPassedInAncestorNotTheHeaviestCommonReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testPassedInAncestorNotTheHeaviestCommonReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testPassedInAncestorNotTheHeaviestCommonCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testPassedInAncestorNotTheHeaviestCommonReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testPassedInAncestorNotTheHeaviestCommon()"; - const SELECTOR: [u8; 4] = [187u8, 138u8, 203u8, 240u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testPassedInAncestorNotTheHeaviestCommonReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testPassedInBestKnowIsUnknown()` and selector `0x18caf916`. -```solidity -function testPassedInBestKnowIsUnknown() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testPassedInBestKnowIsUnknownCall; - ///Container type for the return parameters of the [`testPassedInBestKnowIsUnknown()`](testPassedInBestKnowIsUnknownCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testPassedInBestKnowIsUnknownReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testPassedInBestKnowIsUnknownCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testPassedInBestKnowIsUnknownCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testPassedInBestKnowIsUnknownReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testPassedInBestKnowIsUnknownReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testPassedInBestKnowIsUnknownReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testPassedInBestKnowIsUnknownCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testPassedInBestKnowIsUnknownReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testPassedInBestKnowIsUnknown()"; - const SELECTOR: [u8; 4] = [24u8, 202u8, 249u8, 22u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testPassedInBestKnowIsUnknownReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testPassedInNotTheBestKnown()` and selector `0x529213a1`. -```solidity -function testPassedInNotTheBestKnown() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testPassedInNotTheBestKnownCall; - ///Container type for the return parameters of the [`testPassedInNotTheBestKnown()`](testPassedInNotTheBestKnownCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testPassedInNotTheBestKnownReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testPassedInNotTheBestKnownCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testPassedInNotTheBestKnownCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testPassedInNotTheBestKnownReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testPassedInNotTheBestKnownReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testPassedInNotTheBestKnownReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testPassedInNotTheBestKnownCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testPassedInNotTheBestKnownReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testPassedInNotTheBestKnown()"; - const SELECTOR: [u8; 4] = [82u8, 146u8, 19u8, 161u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testPassedInNotTheBestKnownReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testSuccessfullyMarkHeaviest()` and selector `0xc70f750c`. -```solidity -function testSuccessfullyMarkHeaviest() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testSuccessfullyMarkHeaviestCall; - ///Container type for the return parameters of the [`testSuccessfullyMarkHeaviest()`](testSuccessfullyMarkHeaviestCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testSuccessfullyMarkHeaviestReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testSuccessfullyMarkHeaviestCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testSuccessfullyMarkHeaviestCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testSuccessfullyMarkHeaviestReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testSuccessfullyMarkHeaviestReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testSuccessfullyMarkHeaviestReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testSuccessfullyMarkHeaviestCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testSuccessfullyMarkHeaviestReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testSuccessfullyMarkHeaviest()"; - const SELECTOR: [u8; 4] = [199u8, 15u8, 117u8, 12u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testSuccessfullyMarkHeaviestReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`FullRelayMarkHeaviestTest`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum FullRelayMarkHeaviestTestCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - getBlockHeights(getBlockHeightsCall), - #[allow(missing_docs)] - getDigestLes(getDigestLesCall), - #[allow(missing_docs)] - getHeaderHexes(getHeaderHexesCall), - #[allow(missing_docs)] - getHeaders(getHeadersCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - testPassedInAncestorNotTheHeaviestCommon( - testPassedInAncestorNotTheHeaviestCommonCall, - ), - #[allow(missing_docs)] - testPassedInBestKnowIsUnknown(testPassedInBestKnowIsUnknownCall), - #[allow(missing_docs)] - testPassedInNotTheBestKnown(testPassedInNotTheBestKnownCall), - #[allow(missing_docs)] - testSuccessfullyMarkHeaviest(testSuccessfullyMarkHeaviestCall), - } - #[automatically_derived] - impl FullRelayMarkHeaviestTestCalls { - /// 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, 19u8, 133u8, 42u8], - [24u8, 202u8, 249u8, 22u8], - [28u8, 13u8, 168u8, 31u8], - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [68u8, 186u8, 219u8, 182u8], - [82u8, 146u8, 19u8, 161u8], - [102u8, 217u8, 169u8, 160u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [187u8, 138u8, 203u8, 240u8], - [199u8, 15u8, 117u8, 12u8], - [226u8, 12u8, 159u8, 113u8], - [250u8, 118u8, 38u8, 212u8], - [250u8, 208u8, 107u8, 143u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for FullRelayMarkHeaviestTestCalls { - const NAME: &'static str = "FullRelayMarkHeaviestTestCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 20usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::getBlockHeights(_) => { - ::SELECTOR - } - Self::getDigestLes(_) => { - ::SELECTOR - } - Self::getHeaderHexes(_) => { - ::SELECTOR - } - Self::getHeaders(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::testPassedInAncestorNotTheHeaviestCommon(_) => { - ::SELECTOR - } - Self::testPassedInBestKnowIsUnknown(_) => { - ::SELECTOR - } - Self::testPassedInNotTheBestKnown(_) => { - ::SELECTOR - } - Self::testSuccessfullyMarkHeaviest(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::getHeaderHexes) - } - getHeaderHexes - }, - { - fn testPassedInBestKnowIsUnknown( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - FullRelayMarkHeaviestTestCalls::testPassedInBestKnowIsUnknown, - ) - } - testPassedInBestKnowIsUnknown - }, - { - fn getHeaders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::getHeaders) - } - getHeaders - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::targetContracts) - } - targetContracts - }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::getDigestLes) - } - getDigestLes - }, - { - fn testPassedInNotTheBestKnown( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - FullRelayMarkHeaviestTestCalls::testPassedInNotTheBestKnown, - ) - } - testPassedInNotTheBestKnown - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::targetArtifactSelectors) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(FullRelayMarkHeaviestTestCalls::failed) - } - failed - }, - { - fn testPassedInAncestorNotTheHeaviestCommon( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - FullRelayMarkHeaviestTestCalls::testPassedInAncestorNotTheHeaviestCommon, - ) - } - testPassedInAncestorNotTheHeaviestCommon - }, - { - fn testSuccessfullyMarkHeaviest( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - FullRelayMarkHeaviestTestCalls::testSuccessfullyMarkHeaviest, - ) - } - testSuccessfullyMarkHeaviest - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::excludeContracts) - } - excludeContracts - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(FullRelayMarkHeaviestTestCalls::IS_TEST) - } - IS_TEST - }, - { - fn getBlockHeights( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::getBlockHeights) - } - getBlockHeights - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::getHeaderHexes) - } - getHeaderHexes - }, - { - fn testPassedInBestKnowIsUnknown( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayMarkHeaviestTestCalls::testPassedInBestKnowIsUnknown, - ) - } - testPassedInBestKnowIsUnknown - }, - { - fn getHeaders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::getHeaders) - } - getHeaders - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::targetContracts) - } - targetContracts - }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::getDigestLes) - } - getDigestLes - }, - { - fn testPassedInNotTheBestKnown( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayMarkHeaviestTestCalls::testPassedInNotTheBestKnown, - ) - } - testPassedInNotTheBestKnown - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::targetArtifactSelectors) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::failed) - } - failed - }, - { - fn testPassedInAncestorNotTheHeaviestCommon( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayMarkHeaviestTestCalls::testPassedInAncestorNotTheHeaviestCommon, - ) - } - testPassedInAncestorNotTheHeaviestCommon - }, - { - fn testSuccessfullyMarkHeaviest( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayMarkHeaviestTestCalls::testSuccessfullyMarkHeaviest, - ) - } - testSuccessfullyMarkHeaviest - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::excludeContracts) - } - excludeContracts - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::IS_TEST) - } - IS_TEST - }, - { - fn getBlockHeights( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayMarkHeaviestTestCalls::getBlockHeights) - } - getBlockHeights - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::getBlockHeights(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getDigestLes(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getHeaders(inner) => { - ::abi_encoded_size(inner) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testPassedInAncestorNotTheHeaviestCommon(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testPassedInBestKnowIsUnknown(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testPassedInNotTheBestKnown(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testSuccessfullyMarkHeaviest(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::getBlockHeights(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getDigestLes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testPassedInAncestorNotTheHeaviestCommon(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testPassedInBestKnowIsUnknown(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testPassedInNotTheBestKnown(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testSuccessfullyMarkHeaviest(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`FullRelayMarkHeaviestTest`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum FullRelayMarkHeaviestTestEvents { - #[allow(missing_docs)] - NewTip(NewTip), - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl FullRelayMarkHeaviestTestEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 60u8, 193u8, 61u8, 230u8, 77u8, 240u8, 240u8, 35u8, 150u8, 38u8, 35u8, - 92u8, 81u8, 162u8, 218u8, 37u8, 27u8, 188u8, 140u8, 133u8, 102u8, 78u8, - 204u8, 227u8, 146u8, 99u8, 218u8, 62u8, 224u8, 63u8, 96u8, 108u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for FullRelayMarkHeaviestTestEvents { - const NAME: &'static str = "FullRelayMarkHeaviestTestEvents"; - const COUNT: usize = 23usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::NewTip) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 FullRelayMarkHeaviestTestEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::NewTip(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::NewTip(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`FullRelayMarkHeaviestTest`](self) contract instance. - -See the [wrapper's documentation](`FullRelayMarkHeaviestTestInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> FullRelayMarkHeaviestTestInstance { - FullRelayMarkHeaviestTestInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - FullRelayMarkHeaviestTestInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - FullRelayMarkHeaviestTestInstance::::deploy_builder(provider) - } - /**A [`FullRelayMarkHeaviestTest`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`FullRelayMarkHeaviestTest`](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 FullRelayMarkHeaviestTestInstance< - P, - N = alloy_contract::private::Ethereum, - > { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for FullRelayMarkHeaviestTestInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("FullRelayMarkHeaviestTestInstance") - .field(&self.address) - .finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayMarkHeaviestTestInstance { - /**Creates a new wrapper around an on-chain [`FullRelayMarkHeaviestTest`](self) contract instance. - -See the [wrapper's documentation](`FullRelayMarkHeaviestTestInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 FullRelayMarkHeaviestTestInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> FullRelayMarkHeaviestTestInstance { - FullRelayMarkHeaviestTestInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayMarkHeaviestTestInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`getBlockHeights`] function. - pub fn getBlockHeights( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getBlockHeightsCall, N> { - self.call_builder( - &getBlockHeightsCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getDigestLes`] function. - pub fn getDigestLes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getDigestLesCall, N> { - self.call_builder( - &getDigestLesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaderHexes`] function. - pub fn getHeaderHexes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeaderHexesCall, N> { - self.call_builder( - &getHeaderHexesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaders`] function. - pub fn getHeaders( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeadersCall, N> { - self.call_builder( - &getHeadersCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`testPassedInAncestorNotTheHeaviestCommon`] function. - pub fn testPassedInAncestorNotTheHeaviestCommon( - &self, - ) -> alloy_contract::SolCallBuilder< - &P, - testPassedInAncestorNotTheHeaviestCommonCall, - N, - > { - self.call_builder(&testPassedInAncestorNotTheHeaviestCommonCall) - } - ///Creates a new call builder for the [`testPassedInBestKnowIsUnknown`] function. - pub fn testPassedInBestKnowIsUnknown( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testPassedInBestKnowIsUnknownCall, N> { - self.call_builder(&testPassedInBestKnowIsUnknownCall) - } - ///Creates a new call builder for the [`testPassedInNotTheBestKnown`] function. - pub fn testPassedInNotTheBestKnown( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testPassedInNotTheBestKnownCall, N> { - self.call_builder(&testPassedInNotTheBestKnownCall) - } - ///Creates a new call builder for the [`testSuccessfullyMarkHeaviest`] function. - pub fn testSuccessfullyMarkHeaviest( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testSuccessfullyMarkHeaviestCall, N> { - self.call_builder(&testSuccessfullyMarkHeaviestCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayMarkHeaviestTestInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`NewTip`] event. - pub fn NewTip_filter(&self) -> alloy_contract::Event<&P, NewTip, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/fullrelaywithverifydirecttest.rs b/crates/bindings/src/fullrelaywithverifydirecttest.rs deleted file mode 100644 index 2934835f0..000000000 --- a/crates/bindings/src/fullrelaywithverifydirecttest.rs +++ /dev/null @@ -1,9638 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface FullRelayWithVerifyDirectTest { - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); - function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); - function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); - function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function testGCDDoesntConfirmHeader() external; - function testIncorrectProofSupplied() external; - function testIncorrectTxIdSupplied() external; - function testIncorrectTxSupplied() external; - function testInsufficientConfirmations() external; - function testMalformedProofSupplied() external; - function testSuccessfullyVerify() external view; -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getBlockHeights", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getDigestLes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes32[]", - "internalType": "bytes32[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaderHexes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes[]", - "internalType": "bytes[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaders", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "headers", - "type": "bytes", - "internalType": "bytes" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testGCDDoesntConfirmHeader", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testIncorrectProofSupplied", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testIncorrectTxIdSupplied", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testIncorrectTxSupplied", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testInsufficientConfirmations", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testMalformedProofSupplied", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testSuccessfullyVerify", - "inputs": [], - "outputs": [], - "stateMutability": "view" - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 FullRelayWithVerifyDirectTest { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x600c8054600160ff199182168117909255601f8054909116909117905561010060405260506080818152906156ba60a03960219061003d908261069d565b50604051806101600160405280610140815260200161572a6101409139602290610067908261069d565b507f48e5a1a0e616d8fd92b4ef228c424e0c816799a256c6a90892195ccfc53300d660235561011960245534801561009d575f5ffd5b506040518060400160405280600c81526020016b3432b0b232b939973539b7b760a11b8152506040518060400160405280600c81526020016b05ccecadccae6d2e65cd0caf60a31b8152506040518060400160405280600f81526020016e0b99d95b995cda5ccb9a195a59da1d608a1b815250604051806040016040528060128152602001712e67656e657369732e6469676573745f6c6560701b8152505f5f51602061570a5f395f51905f526001600160a01b031663d930a0e66040518163ffffffff1660e01b81526004015f60405180830381865afa158015610184573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d908101601f191682016040526101ab91908101906107cc565b90505f81866040516020016101c192919061082f565b60408051601f19818403018152908290526360f9bb1160e01b825291505f51602061570a5f395f51905f52906360f9bb11906102019084906004016108a1565b5f60405180830381865afa15801561021b573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d908101601f1916820160405261024291908101906107cc565b60209061024f908261069d565b506102e6856020805461026190610619565b80601f016020809104026020016040519081016040528092919081815260200182805461028d90610619565b80156102d85780601f106102af576101008083540402835291602001916102d8565b820191905f5260205f20905b8154815290600101906020018083116102bb57829003601f168201915b5093949350506104d4915050565b61037c85602080546102f790610619565b80601f016020809104026020016040519081016040528092919081815260200182805461032390610619565b801561036e5780601f106103455761010080835404028352916020019161036e565b820191905f5260205f20905b81548152906001019060200180831161035157829003601f168201915b509394935050610551915050565b610412856020805461038d90610619565b80601f01602080910402602001604051908101604052809291908181526020018280546103b990610619565b80156104045780601f106103db57610100808354040283529160200191610404565b820191905f5260205f20905b8154815290600101906020018083116103e757829003601f168201915b5093949350506105c4915050565b60405161041e906105f8565b61042a939291906108b3565b604051809103905ff080158015610443573d5f5f3e3d5ffd5b50601f8054610100600160a81b0319166101006001600160a01b039384168102919091179182905560405163f58db06f60e01b815260016004820181905260248201529104909116965063f58db06f955060440193506104a292505050565b5f604051808303815f87803b1580156104b9575f5ffd5b505af11580156104cb573d5f5f3e3d5ffd5b50505050610912565b604051631fb2437d60e31b81526060905f51602061570a5f395f51905f529063fd921be89061050990869086906004016108d7565b5f60405180830381865afa158015610523573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d908101601f1916820160405261054a91908101906107cc565b9392505050565b6040516356eef15b60e11b81525f905f51602061570a5f395f51905f529063addde2b69061058590869086906004016108d7565b602060405180830381865afa1580156105a0573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061054a91906108fb565b604051631777e59d60e01b81525f905f51602061570a5f395f51905f5290631777e59d9061058590869086906004016108d7565b61293b80612d7f83390190565b634e487b7160e01b5f52604160045260245ffd5b600181811c9082168061062d57607f821691505b60208210810361064b57634e487b7160e01b5f52602260045260245ffd5b50919050565b601f82111561069857805f5260205f20601f840160051c810160208510156106765750805b601f840160051c820191505b81811015610695575f8155600101610682565b50505b505050565b81516001600160401b038111156106b6576106b6610605565b6106ca816106c48454610619565b84610651565b6020601f8211600181146106fc575f83156106e55750848201515b5f19600385901b1c1916600184901b178455610695565b5f84815260208120601f198516915b8281101561072b578785015182556020948501946001909201910161070b565b508482101561074857868401515f19600387901b60f8161c191681555b50505050600190811b01905550565b5f806001600160401b0384111561077057610770610605565b50604051601f19601f85018116603f011681018181106001600160401b038211171561079e5761079e610605565b6040528381529050808284018510156107b5575f5ffd5b8383602083015e5f60208583010152509392505050565b5f602082840312156107dc575f5ffd5b81516001600160401b038111156107f1575f5ffd5b8201601f81018413610801575f5ffd5b61081084825160208401610757565b949350505050565b5f81518060208401855e5f93019283525090919050565b5f61083a8285610818565b7f2f746573742f66756c6c52656c61792f74657374446174612f00000000000000815261086a6019820185610818565b95945050505050565b5f81518084528060208401602086015e5f602082860101526020601f19601f83011685010191505092915050565b602081525f61054a6020830184610873565b606081525f6108c56060830186610873565b60208301949094525060400152919050565b604081525f6108e96040830185610873565b828103602084015261086a8185610873565b5f6020828403121561090b575f5ffd5b5051919050565b6124608061091f5f395ff3fe608060405234801561000f575f5ffd5b5060043610610184575f3560e01c806385226c81116100dd578063e20c9f7111610088578063f11d5cbc11610063578063f11d5cbc146102cc578063fa7626d4146102d4578063fad06b8f146102e1575f5ffd5b8063e20c9f71146102b4578063e89f8419146102bc578063f0c0832e146102c4575f5ffd5b8063b52b2058116100b8578063b52b20581461028c578063b5508aa914610294578063ba414fa61461029c575f5ffd5b806385226c811461025a578063916a17c61461026f578063b0464fdc14610284575f5ffd5b80633e5e3c231161013d578063641e144d11610118578063641e144d1461023557806366d9a9a01461023d578063740dba7414610252575f5ffd5b80633e5e3c23146102055780633f7286f41461020d57806344badbb614610215575f5ffd5b80631ed7831c1161016d5780631ed7831c146101d15780632ade3880146101e657806339425f8f146101fb575f5ffd5b80630813852a146101885780631c0da81f146101b1575b5f5ffd5b61019b610196366004611b56565b6102f4565b6040516101a89190611c0b565b60405180910390f35b6101c46101bf366004611b56565b61033f565b6040516101a89190611c6e565b6101d96103b1565b6040516101a89190611c80565b6101ee61041e565b6040516101a89190611d32565b610203610567565b005b6101d9610692565b6101d96106fd565b610228610223366004611b56565b610768565b6040516101a89190611db6565b6102036107ab565b6102456108ce565b6040516101a89190611e49565b610203610a47565b610262610b3e565b6040516101a89190611ec7565b610277610c09565b6040516101a89190611ed9565b610277610d0c565b610203610e0f565b610262610e5d565b6102a4610f28565b60405190151581526020016101a8565b6101d9610ff8565b610203611063565b61020361115c565b610203611255565b601f546102a49060ff1681565b6102286102ef366004611b56565b6113da565b60606103378484846040518060400160405280600381526020017f686578000000000000000000000000000000000000000000000000000000000081525061141d565b949350505050565b60605f61034d8585856102f4565b90505f5b61035b8585611f8a565b8110156103a8578282828151811061037557610375611f9d565b602002602001015160405160200161038e929190611fe1565b60408051601f198184030181529190529250600101610351565b50509392505050565b6060601680548060200260200160405190810160405280929190818152602001828054801561041457602002820191905f5260205f20905b815473ffffffffffffffffffffffffffffffffffffffff1681526001909101906020018083116103e9575b5050505050905090565b6060601e805480602002602001604051908101604052809291908181526020015f905b8282101561055e575f848152602080822060408051808201825260028702909201805473ffffffffffffffffffffffffffffffffffffffff168352600181018054835181870281018701909452808452939591948681019491929084015b82821015610547578382905f5260205f200180546104bc90611ff5565b80601f01602080910402602001604051908101604052809291908181526020018280546104e890611ff5565b80156105335780601f1061050a57610100808354040283529160200191610533565b820191905f5260205f20905b81548152906001019060200180831161051657829003601f168201915b50505050508152602001906001019061049f565b505050508152505081526020019060010190610441565b50505050905090565b604080518082018252601a81527f496e73756666696369656e7420636f6e6669726d6174696f6e73000000000000602082015290517ff28dceb3000000000000000000000000000000000000000000000000000000008152737109709ecfa91a80626ff3989d68f67f5b1dd12d9163f28dceb3916105e89190600401611c6e565b5f604051808303815f87803b1580156105ff575f5ffd5b505af1158015610611573d5f5f3e3d5ffd5b5050601f54602354602454604051625d09a760e41b815261010090930473ffffffffffffffffffffffffffffffffffffffff1694506305d09a70935061066492602192602292909160099060040161211b565b5f6040518083038186803b15801561067a575f5ffd5b505afa15801561068c573d5f5f3e3d5ffd5b50505050565b6060601880548060200260200160405190810160405280929190818152602001828054801561041457602002820191905f5260205f2090815473ffffffffffffffffffffffffffffffffffffffff1681526001909101906020018083116103e9575050505050905090565b6060601780548060200260200160405190810160405280929190818152602001828054801561041457602002820191905f5260205f2090815473ffffffffffffffffffffffffffffffffffffffff1681526001909101906020018083116103e9575050505050905090565b60606103378484846040518060400160405280600981526020017f6469676573745f6c65000000000000000000000000000000000000000000000081525061157e565b604080518082018252601381527f42616420696e636c7573696f6e2070726f6f6600000000000000000000000000602082015290517ff28dceb3000000000000000000000000000000000000000000000000000000008152737109709ecfa91a80626ff3989d68f67f5b1dd12d9163f28dceb39161082c9190600401611c6e565b5f604051808303815f87803b158015610843575f5ffd5b505af1158015610855573d5f5f3e3d5ffd5b50505050601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166305d09a706021602260235460245460016108ad9190612160565b5f6040518663ffffffff1660e01b815260040161066495949392919061211b565b6060601b805480602002602001604051908101604052809291908181526020015f905b8282101561055e578382905f5260205f2090600202016040518060400160405290815f8201805461092190611ff5565b80601f016020809104026020016040519081016040528092919081815260200182805461094d90611ff5565b80156109985780601f1061096f57610100808354040283529160200191610998565b820191905f5260205f20905b81548152906001019060200180831161097b57829003601f168201915b5050505050815260200160018201805480602002602001604051908101604052809291908181526020018280548015610a2f57602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916815260200190600401906020826003010492830192600103820291508084116109dc5790505b505050505081525050815260200190600101906108f1565b604080518082018252601381527f42616420696e636c7573696f6e2070726f6f6600000000000000000000000000602082015290517ff28dceb3000000000000000000000000000000000000000000000000000000008152737109709ecfa91a80626ff3989d68f67f5b1dd12d9163f28dceb391610ac89190600401611c6e565b5f604051808303815f87803b158015610adf575f5ffd5b505af1158015610af1573d5f5f3e3d5ffd5b5050601f54602454604051625d09a760e41b815261010090920473ffffffffffffffffffffffffffffffffffffffff1693506305d09a709250610664916021916022915f90600401612173565b6060601a805480602002602001604051908101604052809291908181526020015f905b8282101561055e578382905f5260205f20018054610b7e90611ff5565b80601f0160208091040260200160405190810160405280929190818152602001828054610baa90611ff5565b8015610bf55780601f10610bcc57610100808354040283529160200191610bf5565b820191905f5260205f20905b815481529060010190602001808311610bd857829003601f168201915b505050505081526020019060010190610b61565b6060601d805480602002602001604051908101604052809291908181526020015f905b8282101561055e575f84815260209081902060408051808201825260028602909201805473ffffffffffffffffffffffffffffffffffffffff168352600181018054835181870281018701909452808452939491938583019392830182828015610cf457602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191681526020019060040190602082600301049283019260010382029150808411610ca15790505b50505050508152505081526020019060010190610c2c565b6060601c805480602002602001604051908101604052809291908181526020015f905b8282101561055e575f84815260209081902060408051808201825260028602909201805473ffffffffffffffffffffffffffffffffffffffff168352600181018054835181870281018701909452808452939491938583019392830182828015610df757602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191681526020019060040190602082600301049283019260010382029150808411610da45790505b50505050508152505081526020019060010190610d2f565b601f54602354602454604051625d09a760e41b815261010090930473ffffffffffffffffffffffffffffffffffffffff16926305d09a70926106649260219260229291905f9060040161211b565b60606019805480602002602001604051908101604052809291908181526020015f905b8282101561055e578382905f5260205f20018054610e9d90611ff5565b80601f0160208091040260200160405190810160405280929190818152602001828054610ec990611ff5565b8015610f145780601f10610eeb57610100808354040283529160200191610f14565b820191905f5260205f20905b815481529060010190602001808311610ef757829003601f168201915b505050505081526020019060010190610e80565b6008545f9060ff1615610f3f575060085460ff1690565b6040517f667f9d70000000000000000000000000000000000000000000000000000000008152737109709ecfa91a80626ff3989d68f67f5b1dd12d600482018190527f6661696c6564000000000000000000000000000000000000000000000000000060248301525f9163667f9d7090604401602060405180830381865afa158015610fcd573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610ff191906121b8565b1415905090565b6060601580548060200260200160405190810160405280929190818152602001828054801561041457602002820191905f5260205f2090815473ffffffffffffffffffffffffffffffffffffffff1681526001909101906020018083116103e9575050505050905090565b604080518082018252601381527f42616420696e636c7573696f6e2070726f6f6600000000000000000000000000602082015290517ff28dceb3000000000000000000000000000000000000000000000000000000008152737109709ecfa91a80626ff3989d68f67f5b1dd12d9163f28dceb3916110e49190600401611c6e565b5f604051808303815f87803b1580156110fb575f5ffd5b505af115801561110d573d5f5f3e3d5ffd5b5050601f54602354602454604051625d09a760e41b815261010090930473ffffffffffffffffffffffffffffffffffffffff1694506305d09a7093506106649260219291905f906004016121cf565b604080518082018252601681527f426164206d65726b6c652061727261792070726f6f6600000000000000000000602082015290517ff28dceb3000000000000000000000000000000000000000000000000000000008152737109709ecfa91a80626ff3989d68f67f5b1dd12d9163f28dceb3916111dd9190600401611c6e565b5f604051808303815f87803b1580156111f4575f5ffd5b505af1158015611206573d5f5f3e3d5ffd5b5050601f54602354602454604051625d09a760e41b815261010090930473ffffffffffffffffffffffffffffffffffffffff1694506305d09a7093506106649260219291905f90600401612218565b601f546040517ff58db06f0000000000000000000000000000000000000000000000000000000081525f60048201819052602482015261010090910473ffffffffffffffffffffffffffffffffffffffff169063f58db06f906044015f604051808303815f87803b1580156112c8575f5ffd5b505af11580156112da573d5f5f3e3d5ffd5b5050604080518082018252601b81527f47434420646f6573206e6f7420636f6e6669726d206865616465720000000000602082015290517ff28dceb3000000000000000000000000000000000000000000000000000000008152737109709ecfa91a80626ff3989d68f67f5b1dd12d935063f28dceb3925061135f9190600401611c6e565b5f604051808303815f87803b158015611376575f5ffd5b505af1158015611388573d5f5f3e3d5ffd5b5050601f54602354602454604051625d09a760e41b815261010090930473ffffffffffffffffffffffffffffffffffffffff1694506305d09a7093506106649260219260229290915f9060040161211b565b60606103378484846040518060400160405280600681526020017f68656967687400000000000000000000000000000000000000000000000000008152506116cc565b60606114298484611f8a565b67ffffffffffffffff81111561144157611441611ad1565b60405190808252806020026020018201604052801561147457816020015b606081526020019060019003908161145f5790505b509050835b83811015611575576115478661148e8361181a565b856040516020016114a193929190612261565b604051602081830303815290604052602080546114bd90611ff5565b80601f01602080910402602001604051908101604052809291908181526020018280546114e990611ff5565b80156115345780601f1061150b57610100808354040283529160200191611534565b820191905f5260205f20905b81548152906001019060200180831161151757829003601f168201915b505050505061194b90919063ffffffff16565b826115528784611f8a565b8151811061156257611562611f9d565b6020908102919091010152600101611479565b50949350505050565b606061158a8484611f8a565b67ffffffffffffffff8111156115a2576115a2611ad1565b6040519080825280602002602001820160405280156115cb578160200160208202803683370190505b509050835b838110156115755761169e866115e58361181a565b856040516020016115f893929190612261565b6040516020818303038152906040526020805461161490611ff5565b80601f016020809104026020016040519081016040528092919081815260200182805461164090611ff5565b801561168b5780601f106116625761010080835404028352916020019161168b565b820191905f5260205f20905b81548152906001019060200180831161166e57829003601f168201915b50505050506119ea90919063ffffffff16565b826116a98784611f8a565b815181106116b9576116b9611f9d565b60209081029190910101526001016115d0565b60606116d88484611f8a565b67ffffffffffffffff8111156116f0576116f0611ad1565b604051908082528060200260200182016040528015611719578160200160208202803683370190505b509050835b83811015611575576117ec866117338361181a565b8560405160200161174693929190612261565b6040516020818303038152906040526020805461176290611ff5565b80601f016020809104026020016040519081016040528092919081815260200182805461178e90611ff5565b80156117d95780601f106117b0576101008083540402835291602001916117d9565b820191905f5260205f20905b8154815290600101906020018083116117bc57829003601f168201915b5050505050611a7d90919063ffffffff16565b826117f78784611f8a565b8151811061180757611807611f9d565b602090810291909101015260010161171e565b6060815f0361185c57505060408051808201909152600181527f3000000000000000000000000000000000000000000000000000000000000000602082015290565b815f5b8115611885578061186f816122fe565b915061187e9050600a83612362565b915061185f565b5f8167ffffffffffffffff81111561189f5761189f611ad1565b6040519080825280601f01601f1916602001820160405280156118c9576020820181803683370190505b5090505b8415610337576118de600183611f8a565b91506118eb600a86612375565b6118f6906030612160565b60f81b81838151811061190b5761190b611f9d565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff191690815f1a905350611944600a86612362565b94506118cd565b6040517ffd921be8000000000000000000000000000000000000000000000000000000008152606090737109709ecfa91a80626ff3989d68f67f5b1dd12d9063fd921be8906119a09086908690600401612388565b5f60405180830381865afa1580156119ba573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d908101601f191682016040526119e191908101906123b5565b90505b92915050565b6040517f1777e59d0000000000000000000000000000000000000000000000000000000081525f90737109709ecfa91a80626ff3989d68f67f5b1dd12d90631777e59d90611a3e9086908690600401612388565b602060405180830381865afa158015611a59573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906119e191906121b8565b6040517faddde2b60000000000000000000000000000000000000000000000000000000081525f90737109709ecfa91a80626ff3989d68f67f5b1dd12d9063addde2b690611a3e9086908690600401612388565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b604051601f8201601f1916810167ffffffffffffffff81118282101715611b2757611b27611ad1565b604052919050565b5f67ffffffffffffffff821115611b4857611b48611ad1565b50601f01601f191660200190565b5f5f5f60608486031215611b68575f5ffd5b833567ffffffffffffffff811115611b7e575f5ffd5b8401601f81018613611b8e575f5ffd5b8035611ba1611b9c82611b2f565b611afe565b818152876020838501011115611bb5575f5ffd5b816020840160208301375f602092820183015297908601359650604090950135949350505050565b5f81518084528060208401602086015e5f602082860101526020601f19601f83011685010191505092915050565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b82811015611c6257603f19878603018452611c4d858351611bdd565b94506020938401939190910190600101611c31565b50929695505050505050565b602081525f6119e16020830184611bdd565b602080825282518282018190525f918401906040840190835b81811015611ccd57835173ffffffffffffffffffffffffffffffffffffffff16835260209384019390920191600101611c99565b509095945050505050565b5f82825180855260208501945060208160051b830101602085015f5b83811015611d2657601f19858403018852611d10838351611bdd565b6020988901989093509190910190600101611cf4565b50909695505050505050565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b82811015611c6257603f19878603018452815173ffffffffffffffffffffffffffffffffffffffff81511686526020810151905060406020870152611da06040870182611cd8565b9550506020938401939190910190600101611d58565b602080825282518282018190525f918401906040840190835b81811015611ccd578351835260209384019390920191600101611dcf565b5f8151808452602084019350602083015f5b82811015611e3f5781517fffffffff0000000000000000000000000000000000000000000000000000000016865260209586019590910190600101611dff565b5093949350505050565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b82811015611c6257603f198786030184528151805160408752611e956040880182611bdd565b9050602082015191508681036020880152611eb08183611ded565b965050506020938401939190910190600101611e6f565b602081525f6119e16020830184611cd8565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b82811015611c6257603f19878603018452815173ffffffffffffffffffffffffffffffffffffffff81511686526020810151905060406020870152611f476040870182611ded565b9550506020938401939190910190600101611eff565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b818103818111156119e4576119e4611f5d565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b5f81518060208401855e5f93019283525090919050565b5f610337611fef8386611fca565b84611fca565b600181811c9082168061200957607f821691505b602082108103612040577f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b50919050565b80545f90600181811c9082168061205e57607f821691505b602082108103612095577f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b818652602086018180156120b057600181146120e457612110565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff008516825283151560051b82019550612110565b5f878152602090205f5b8581101561210a578154848201526001909101906020016120ee565b83019650505b505050505092915050565b60a081525f61212d60a0830188612046565b828103602084015261213f8188612046565b60408401969096525050606081019290925260ff1660809091015292915050565b808201808211156119e4576119e4611f5d565b60a081525f61218560a0830187612046565b82810360208401526121978187612046565b9150505f604083015283606083015260ff8316608083015295945050505050565b5f602082840312156121c8575f5ffd5b5051919050565b60a081525f6121e160a0830187612046565b8281036020840152602081525f60208201526040810191505084604083015283606083015260ff8316608083015295945050505050565b60a081525f61222a60a0830187612046565b8281036020840152600181525f60208201526040810191505084604083015283606083015260ff8316608083015295945050505050565b7f2e0000000000000000000000000000000000000000000000000000000000000081525f6122926001830186611fca565b7f5b0000000000000000000000000000000000000000000000000000000000000081526122c26001820186611fca565b90507f5d2e00000000000000000000000000000000000000000000000000000000000081526122f46002820185611fca565b9695505050505050565b5f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff820361232e5761232e611f5d565b5060010190565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b5f8261237057612370612335565b500490565b5f8261238357612383612335565b500690565b604081525f61239a6040830185611bdd565b82810360208401526123ac8185611bdd565b95945050505050565b5f602082840312156123c5575f5ffd5b815167ffffffffffffffff8111156123db575f5ffd5b8201601f810184136123eb575f5ffd5b80516123f9611b9c82611b2f565b81815285602083850101111561240d575f5ffd5b8160208401602083015e5f9181016020019190915294935050505056fea2646970667358221220b9cd84ef6bff8da12175e3961d9bc136332f774fe1040e51f80a619ba8b67b3d64736f6c634300081c0033608060405234801561000f575f5ffd5b5060405161293b38038061293b83398101604081905261002e9161032b565b82828282828261003f835160501490565b6100845760405162461bcd60e51b81526020600482015260116024820152704261642067656e6573697320626c6f636b60781b60448201526064015b60405180910390fd5b5f61008e84610166565b905062ffffff8216156101095760405162461bcd60e51b815260206004820152603d60248201527f506572696f64207374617274206861736820646f6573206e6f7420686176652060448201527f776f726b2e2048696e743a2077726f6e672062797465206f726465723f000000606482015260840161007b565b5f818155600182905560028290558181526004602052604090208390556101326107e0846103fe565b61013c9084610425565b5f8381526004602052604090205561015384610226565b600555506105bd98505050505050505050565b5f600280836040516101789190610438565b602060405180830381855afa158015610193573d5f5f3e3d5ffd5b5050506040513d601f19601f820116820180604052508101906101b6919061044e565b6040516020016101c891815260200190565b60408051601f19818403018152908290526101e291610438565b602060405180830381855afa1580156101fd573d5f5f3e3d5ffd5b5050506040513d601f19601f82011682018060405250810190610220919061044e565b92915050565b5f61022061023383610238565b610243565b5f6102208282610253565b5f61022061ffff60d01b836102f7565b5f8061026a610263846048610465565b8590610309565b60e81c90505f8461027c85604b610465565b8151811061028c5761028c610478565b016020015160f81c90505f6102be835f60108262ffffff16901c8261ff001660108462ffffff16901b17179050919050565b62ffffff1690505f6102d160038461048c565b60ff1690506102e281610100610588565b6102ec9083610593565b979650505050505050565b5f61030282846105aa565b9392505050565b5f6103028383016020015190565b634e487b7160e01b5f52604160045260245ffd5b5f5f5f6060848603121561033d575f5ffd5b83516001600160401b03811115610352575f5ffd5b8401601f81018613610362575f5ffd5b80516001600160401b0381111561037b5761037b610317565b604051601f8201601f19908116603f011681016001600160401b03811182821017156103a9576103a9610317565b6040528181528282016020018810156103c0575f5ffd5b8160208401602083015e5f6020928201830152908601516040909601519097959650949350505050565b634e487b7160e01b5f52601260045260245ffd5b5f8261040c5761040c6103ea565b500690565b634e487b7160e01b5f52601160045260245ffd5b8181038181111561022057610220610411565b5f82518060208501845e5f920191825250919050565b5f6020828403121561045e575f5ffd5b5051919050565b8082018082111561022057610220610411565b634e487b7160e01b5f52603260045260245ffd5b60ff828116828216039081111561022057610220610411565b6001815b60018411156104e0578085048111156104c4576104c4610411565b60018416156104d257908102905b60019390931c9280026104a9565b935093915050565b5f826104f657506001610220565b8161050257505f610220565b816001811461051857600281146105225761053e565b6001915050610220565b60ff84111561053357610533610411565b50506001821b610220565b5060208310610133831016604e8410600b8410161715610561575081810a610220565b61056d5f1984846104a5565b805f190482111561058057610580610411565b029392505050565b5f61030283836104e8565b808202811582820484141761022057610220610411565b5f826105b8576105b86103ea565b500490565b612371806105ca5f395ff3fe608060405234801561000f575f5ffd5b5060043610610115575f3560e01c806370d53c18116100ad578063b985621a1161007d578063e3d8d8d811610063578063e3d8d8d814610222578063e471e72c14610229578063f58db06f1461023c575f5ffd5b8063b985621a14610207578063c58242cd1461021a575f5ffd5b806370d53c18146101b157806374c3a3a9146101ce5780637fa637fc146101e1578063b25b9b00146101f4575f5ffd5b80632e4f161a116100e85780632e4f161a1461015557806330017b3b1461017857806360b5c3901461018b57806365da41b91461019e575f5ffd5b806305d09a7014610119578063113764be1461012e5780631910d973146101455780632b97be241461014d575b5f5ffd5b61012c610127366004611d7b565b6102a8565b005b6005545b6040519081526020015b60405180910390f35b600154610132565b600654610132565b610168610163366004611e0c565b6104e1565b604051901515815260200161013c565b610132610186366004611e3b565b6104f9565b610132610199366004611e5b565b61050d565b6101686101ac366004611e72565b610517565b6101b9600481565b60405163ffffffff909116815260200161013c565b6101686101dc366004611ede565b6106c3565b6101686101ef366004611f5f565b610838565b610132610202366004611ffe565b610a17565b610168610215366004612077565b610a94565b600254610132565b5f54610132565b61012c6102373660046120a0565b610aaa565b61012c61024a3660046120d9565b600780547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000169215157fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff169290921761010091151591909102179055565b6102e687878080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610b6892505050565b6103375760405162461bcd60e51b815260206004820152601060248201527f4261642068656164657220626c6f636b0000000000000000000000000000000060448201526064015b60405180910390fd5b61037585858080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610b6f92505050565b6103c15760405162461bcd60e51b815260206004820152601660248201527f426164206d65726b6c652061727261792070726f6f6600000000000000000000604482015260640161032e565b6104408361040389898080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610b8592505050565b87878080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250889250610b91915050565b61048c5760405162461bcd60e51b815260206004820152601360248201527f42616420696e636c7573696f6e2070726f6f6600000000000000000000000000604482015260640161032e565b5f6104cb88888080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610bc392505050565b90506104d78183610aaa565b5050505050505050565b5f6104ee85858585610c9b565b90505b949350505050565b5f6105048383610d35565b90505b92915050565b5f61050782610da7565b5f61055683838080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610e5592505050565b6105c85760405162461bcd60e51b815260206004820152602b60248201527f486561646572206172726179206c656e677468206d757374206265206469766960448201527f7369626c65206279203830000000000000000000000000000000000000000000606482015260840161032e565b61060685858080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610b6892505050565b6106525760405162461bcd60e51b815260206004820152601760248201527f416e63686f72206d757374206265203830206279746573000000000000000000604482015260640161032e565b6104ee85858080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525050604080516020601f890181900481028201810190925287815292508791508690819084018382808284375f9201829052509250610e64915050565b5f61070284848080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610b6892505050565b8015610747575061074786868080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610b6892505050565b6107b95760405162461bcd60e51b815260206004820152602e60248201527f42616420617267732e20436865636b2068656164657220616e6420617272617960448201527f2062797465206c656e677468732e000000000000000000000000000000000000606482015260840161032e565b61082d8787878080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525050604080516020601f8b0181900481028201810190925289815292508991508890819084018382808284375f92019190915250889250611251915050565b979650505050505050565b5f61087787878080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610b6892505050565b80156108bc57506108bc85858080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610b6892505050565b8015610901575061090183838080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250610e5592505050565b6109735760405162461bcd60e51b815260206004820152602e60248201527f42616420617267732e20436865636b2068656164657220616e6420617272617960448201527f2062797465206c656e677468732e000000000000000000000000000000000000606482015260840161032e565b61082d87878080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525050604080516020601f8b0181900481028201810190925289815292508991508890819084018382808284375f9201919091525050604080516020601f8a0181900481028201810190925288815292508891508790819084018382808284375f920191909152506114ee92505050565b5f610a8a8686868080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525050604080516020601f8a0181900481028201810190925288815292508891508790819084018382808284375f9201919091525061178092505050565b9695505050505050565b5f610aa0848484611911565b90505b9392505050565b5f610ab460025490565b9050610ac38382610800611911565b610b0f5760405162461bcd60e51b815260206004820152601b60248201527f47434420646f6573206e6f7420636f6e6669726d206865616465720000000000604482015260640161032e565b60ff821660081015610b635760405162461bcd60e51b815260206004820152601a60248201527f496e73756666696369656e7420636f6e6669726d6174696f6e73000000000000604482015260640161032e565b505050565b5160501490565b5f60208251610b7e919061212e565b1592915050565b60448101515f90610507565b5f8385148015610b9f575081155b8015610baa57508251155b15610bb7575060016104f1565b6104ee85848685611941565b5f60028083604051610bd59190612141565b602060405180830381855afa158015610bf0573d5f5f3e3d5ffd5b5050506040513d601f19601f82011682018060405250810190610c139190612157565b604051602001610c2591815260200190565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe081840301815290829052610c5d91612141565b602060405180830381855afa158015610c78573d5f5f3e3d5ffd5b5050506040513d601f19601f820116820180604052508101906105079190612157565b5f8385148015610caa57508285145b15610cb7575060016104f1565b838381815f5b86811015610cff57898314610cde575f838152600360205260409020549294505b898214610cf7575f828152600360205260409020549193505b600101610cbd565b50828403610d13575f9450505050506104f1565b808214610d26575f9450505050506104f1565b50600198975050505050505050565b5f82815b83811015610d59575f918252600360205260409091205490600101610d39565b50806105045760405162461bcd60e51b815260206004820152601060248201527f556e6b6e6f776e20616e636573746f7200000000000000000000000000000000604482015260640161032e565b5f8082815b610db86004600161219b565b63ffffffff16811015610e0c575f828152600460205260408120549350839003610df1575f918252600360205260409091205490610e04565b610dfb81846121b7565b95945050505050565b600101610dac565b5060405162461bcd60e51b815260206004820152600d60248201527f556e6b6e6f776e20626c6f636b00000000000000000000000000000000000000604482015260640161032e565b5f60508251610b7e919061212e565b5f5f610e6f85610bc3565b90505f610e7b82610da7565b90505f610e87866119e6565b90508480610e9c575080610e9a886119e6565b145b610f0d5760405162461bcd60e51b8152602060048201526024808201527f556e6578706563746564207265746172676574206f6e2065787465726e616c2060448201527f63616c6c00000000000000000000000000000000000000000000000000000000606482015260840161032e565b85515f908190815b8181101561120e57610f286050826121ca565b610f339060016121b7565b610f3d90876121b7565b9350610f4b8a8260506119f1565b5f8181526003602052604090205490935061112157846110a1845f8190506008817eff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff16901b600882901c7eff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff161790506010817dffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff16901b601082901c7dffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff161790506020817bffffffff00000000ffffffff00000000ffffffff00000000ffffffff16901b602082901c7bffffffff00000000ffffffff00000000ffffffff00000000ffffffff1617905060408177ffffffffffffffff0000000000000000ffffffffffffffff16901b604082901c77ffffffffffffffff0000000000000000ffffffffffffffff16179050608081901b608082901c179050919050565b11156110ef5760405162461bcd60e51b815260206004820152601b60248201527f48656164657220776f726b20697320696e73756666696369656e740000000000604482015260640161032e565b5f83815260036020526040902087905561110a60048561212e565b5f03611121575f8381526004602052604090208490555b8461112c8b83611a16565b146111795760405162461bcd60e51b815260206004820152601b60248201527f546172676574206368616e67656420756e65787065637465646c790000000000604482015260640161032e565b866111848b83611aaf565b146111f75760405162461bcd60e51b815260206004820152602660248201527f4865616465727320646f206e6f7420666f726d206120636f6e73697374656e7460448201527f20636861696e0000000000000000000000000000000000000000000000000000606482015260840161032e565b82965060508161120791906121b7565b9050610f15565b50816112198b610bc3565b6040517ff90e4f1d9cd0dd55e339411cbc9b152482307c3a23ed64715e4a2858f641a3f5905f90a35060019998505050505050505050565b5f6107e08211156112ca5760405162461bcd60e51b815260206004820152603360248201527f526571756573746564206c696d69742069732067726561746572207468616e2060448201527f3120646966666963756c747920706572696f6400000000000000000000000000606482015260840161032e565b5f6112d484610bc3565b90505f6112e086610bc3565b905060015481146113335760405162461bcd60e51b815260206004820181905260248201527f50617373656420696e2062657374206973206e6f742062657374206b6e6f776e604482015260640161032e565b5f8281526003602052604090205461138d5760405162461bcd60e51b815260206004820152601360248201527f4e6577206265737420697320756e6b6e6f776e00000000000000000000000000604482015260640161032e565b61139b876001548487610c9b565b61140d5760405162461bcd60e51b815260206004820152602960248201527f416e636573746f72206d75737420626520686561766965737420636f6d6d6f6e60448201527f20616e636573746f720000000000000000000000000000000000000000000000606482015260840161032e565b81611419888888611780565b1461148c5760405162461bcd60e51b815260206004820152603360248201527f4e65772062657374206861736820646f6573206e6f742068617665206d6f726560448201527f20776f726b207468616e2070726576696f757300000000000000000000000000606482015260840161032e565b600182905560028790555f6114a086611ac7565b905060055481146114b15760058190555b8783837f3cc13de64df0f0239626235c51a2da251bbc8c85664ecce39263da3ee03f606c60405160405180910390a4506001979650505050505050565b5f5f6115016114fc86610bc3565b610da7565b90505f6115106114fc86610bc3565b905061151e6107e08261212e565b6107df146115945760405162461bcd60e51b815260206004820152603d60248201527f4d7573742070726f7669646520746865206c61737420686561646572206f662060448201527f74686520636c6f73696e6720646966666963756c747920706572696f64000000606482015260840161032e565b6115a0826107df6121b7565b81146116145760405162461bcd60e51b815260206004820152602860248201527f4d7573742070726f766964652065786163746c79203120646966666963756c7460448201527f7920706572696f64000000000000000000000000000000000000000000000000606482015260840161032e565b61161d85611ac7565b61162687611ac7565b146116995760405162461bcd60e51b815260206004820152602760248201527f506572696f642068656164657220646966666963756c7469657320646f206e6f60448201527f74206d6174636800000000000000000000000000000000000000000000000000606482015260840161032e565b5f6116a3856119e6565b90505f6116d56116b2896119e6565b6116bb8a611ad9565b63ffffffff166116ca8a611ad9565b63ffffffff16611b0c565b905081818316146117285760405162461bcd60e51b815260206004820152601960248201527f496e76616c69642072657461726765742070726f766964656400000000000000604482015260640161032e565b5f61173289611ac7565b9050806006541415801561175c57506107e061174f600154610da7565b61175991906121dd565b84115b156117675760068190555b61177388886001610e64565b9998505050505050505050565b5f5f61178b85610da7565b90505f61179a6114fc86610bc3565b90505f6117a96114fc86610bc3565b90508282101580156117bb5750828110155b61182d5760405162461bcd60e51b815260206004820152603060248201527f412064657363656e64616e74206865696768742069732062656c6f772074686560448201527f20616e636573746f722068656967687400000000000000000000000000000000606482015260840161032e565b5f61183a6107e08561212e565b611846856107e06121b7565b61185091906121dd565b90508083108183108115826118625750805b1561187d5761187089610bc3565b9650505050505050610aa3565b818015611888575080155b156118965761187088610bc3565b8180156118a05750805b156118c457838510156118bb576118b688610bc3565b611870565b61187089610bc3565b6118cd88611ac7565b6118d96107e08661212e565b6118e391906121f0565b6118ec8a611ac7565b6118f86107e08861212e565b61190291906121f0565b10156118bb5761187088610bc3565b6007545f9060ff161561192f5750600754610100900460ff16610aa3565b61193a848484611b94565b9050610aa3565b5f60208451611950919061212e565b1561195c57505f6104f1565b83515f0361196b57505f6104f1565b81855f5b86518110156119d95761198360028461212e565b6001036119a7576119a061199a8883016020015190565b83611bd5565b91506119c0565b6119bd826119b88984016020015190565b611bd5565b91505b60019290921c916119d26020826121b7565b905061196f565b5090931495945050505050565b5f610507825f611a16565b5f60205f8385602001870160025afa5060205f60205f60025afa50505f519392505050565b5f80611a2d611a268460486121b7565b8590611be0565b60e81c90505f84611a3f85604b6121b7565b81518110611a4f57611a4f612207565b016020015160f81c90505f611a81835f60108262ffffff16901c8261ff001660108462ffffff16901b17179050919050565b62ffffff1690505f611a94600384612234565b60ff169050611aa581610100612330565b61082d90836121f0565b5f610504611abe8360046121b7565b84016020015190565b5f610507611ad4836119e6565b611bee565b5f610507611ae683611c15565b60d881901c63ff00ff001662ff00ff60e89290921c9190911617601081811b91901c1790565b5f80611b188385611c21565b9050611b28621275006004611c7c565b811015611b4057611b3d621275006004611c7c565b90505b611b4e621275006004611c87565b811115611b6657611b63621275006004611c87565b90505b5f611b7e82611b788862010000611c7c565b90611c87565b9050610a8a62010000611b788362127500611c7c565b5f82815b83811015611bca57858203611bb257600192505050610aa3565b5f918252600360205260409091205490600101611b98565b505f95945050505050565b5f6105048383611cfa565b5f6105048383016020015190565b5f6105077bffff000000000000000000000000000000000000000000000000000083611c7c565b5f610507826044611be0565b5f82821115611c725760405162461bcd60e51b815260206004820152601d60248201527f556e646572666c6f7720647572696e67207375627472616374696f6e2e000000604482015260640161032e565b61050482846121dd565b5f61050482846121ca565b5f825f03611c9657505f610507565b611ca082846121f0565b905081611cad84836121ca565b146105075760405162461bcd60e51b815260206004820152601f60248201527f4f766572666c6f7720647572696e67206d756c7469706c69636174696f6e2e00604482015260640161032e565b5f825f528160205260205f60405f60025afa5060205f60205f60025afa50505f5192915050565b5f5f83601f840112611d31575f5ffd5b50813567ffffffffffffffff811115611d48575f5ffd5b602083019150836020828501011115611d5f575f5ffd5b9250929050565b803560ff81168114611d76575f5ffd5b919050565b5f5f5f5f5f5f5f60a0888a031215611d91575f5ffd5b873567ffffffffffffffff811115611da7575f5ffd5b611db38a828b01611d21565b909850965050602088013567ffffffffffffffff811115611dd2575f5ffd5b611dde8a828b01611d21565b9096509450506040880135925060608801359150611dfe60808901611d66565b905092959891949750929550565b5f5f5f5f60808587031215611e1f575f5ffd5b5050823594602084013594506040840135936060013592509050565b5f5f60408385031215611e4c575f5ffd5b50508035926020909101359150565b5f60208284031215611e6b575f5ffd5b5035919050565b5f5f5f5f60408587031215611e85575f5ffd5b843567ffffffffffffffff811115611e9b575f5ffd5b611ea787828801611d21565b909550935050602085013567ffffffffffffffff811115611ec6575f5ffd5b611ed287828801611d21565b95989497509550505050565b5f5f5f5f5f5f60808789031215611ef3575f5ffd5b86359550602087013567ffffffffffffffff811115611f10575f5ffd5b611f1c89828a01611d21565b909650945050604087013567ffffffffffffffff811115611f3b575f5ffd5b611f4789828a01611d21565b979a9699509497949695606090950135949350505050565b5f5f5f5f5f5f60608789031215611f74575f5ffd5b863567ffffffffffffffff811115611f8a575f5ffd5b611f9689828a01611d21565b909750955050602087013567ffffffffffffffff811115611fb5575f5ffd5b611fc189828a01611d21565b909550935050604087013567ffffffffffffffff811115611fe0575f5ffd5b611fec89828a01611d21565b979a9699509497509295939492505050565b5f5f5f5f5f60608688031215612012575f5ffd5b85359450602086013567ffffffffffffffff81111561202f575f5ffd5b61203b88828901611d21565b909550935050604086013567ffffffffffffffff81111561205a575f5ffd5b61206688828901611d21565b969995985093965092949392505050565b5f5f5f60608486031215612089575f5ffd5b505081359360208301359350604090920135919050565b5f5f604083850312156120b1575f5ffd5b823591506120c160208401611d66565b90509250929050565b80358015158114611d76575f5ffd5b5f5f604083850312156120ea575f5ffd5b6120f3836120ca565b91506120c1602084016120ca565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b5f8261213c5761213c612101565b500690565b5f82518060208501845e5f920191825250919050565b5f60208284031215612167575f5ffd5b5051919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b63ffffffff81811683821601908111156105075761050761216e565b808201808211156105075761050761216e565b5f826121d8576121d8612101565b500490565b818103818111156105075761050761216e565b80820281158282048414176105075761050761216e565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b60ff82811682821603908111156105075761050761216e565b6001815b60018411156122885780850481111561226c5761226c61216e565b600184161561227a57908102905b60019390931c928002612251565b935093915050565b5f8261229e57506001610507565b816122aa57505f610507565b81600181146122c057600281146122ca576122e6565b6001915050610507565b60ff8411156122db576122db61216e565b50506001821b610507565b5060208310610133831016604e8410600b8410161715612309575081810a610507565b6123155f19848461224d565b805f19048211156123285761232861216e565b029392505050565b5f610504838361229056fea26469706673582212201142af7e12173b7a99dd453dfc892e01c9c1e5b63659b60c61d3e9d80122f9eb64736f6c634300081c00330000002073bd2184edd9c4fc76642ea6754ee40136970efc10c4190000000000000000000296ef123ea96da5cf695f22bf7d94be87d49db1ad7ac371ac43c4da4161c8c216349c5ba11928170d38782b0000000000000000000000007109709ecfa91a80626ff3989d68f67f5b1dd12de35a0d6de94b656694589964a252957e4673a9fb1d2f8b4a92e3f0a7bb654fddb94e5a1e6d7f7f499fd1be5dd30a73bf5584bf137da5fdd77cc21aeb95b9e35788894be019284bd4fbed6dd6118ac2cb6d26bc4be4e423f55a3a48f2874d8d02a65d9c87d07de21d4dfe7b0a9f4a23cc9a58373e9e6931fefdb5afade5df54c91104048df1ee999240617984e18b6f931e2373673d0195b8c6987d7ff7650d5ce53bcec46e13ab4f2da1146a7fc621ee672f62bc22742486392d75e55e67b09960c3386a0b49e75f1723d6ab28ac9a2028a0c72866e2111d79d4817b88e17c821937847768d92837bae3832bb8e5a4ab4434b97e00a6c10182f211f592409068d6f5652400d9a3d1cc150a7fb692e874cc42d76bdafc842f2fe0f835a7c24d2d60c109b187d64571efbaa8047be85821f8e67e0e85f2f5894bc63d00c2ed9d64 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90Ua\x01\0`@R`P`\x80\x81\x81R\x90aV\xBA`\xA09`!\x90a\0=\x90\x82a\x06\x9DV[P`@Q\x80a\x01`\x01`@R\x80a\x01@\x81R` \x01aW*a\x01@\x919`\"\x90a\0g\x90\x82a\x06\x9DV[P\x7FH\xE5\xA1\xA0\xE6\x16\xD8\xFD\x92\xB4\xEF\"\x8CBN\x0C\x81g\x99\xA2V\xC6\xA9\x08\x92\x19\\\xCF\xC53\0\xD6`#Ua\x01\x19`$U4\x80\x15a\0\x9DW__\xFD[P`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k42\xB0\xB22\xB99\x9759\xB7\xB7`\xA1\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k\x05\xCC\xEC\xAD\xCC\xAEm.e\xCD\x0C\xAF`\xA3\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x0F\x81R` \x01n\x0B\x99\xD9[\x99\\\xDA\\\xCB\x9A\x19ZY\xDA\x1D`\x8A\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01q.genesis.digest_le`p\x1B\x81RP__Q` aW\n_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x16c\xD90\xA0\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\x84W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01\xAB\x91\x90\x81\x01\x90a\x07\xCCV[\x90P_\x81\x86`@Q` \x01a\x01\xC1\x92\x91\x90a\x08/V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Rc`\xF9\xBB\x11`\xE0\x1B\x82R\x91P_Q` aW\n_9_Q\x90_R\x90c`\xF9\xBB\x11\x90a\x02\x01\x90\x84\x90`\x04\x01a\x08\xA1V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x1BW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x02B\x91\x90\x81\x01\x90a\x07\xCCV[` \x90a\x02O\x90\x82a\x06\x9DV[Pa\x02\xE6\x85` \x80Ta\x02a\x90a\x06\x19V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\x8D\x90a\x06\x19V[\x80\x15a\x02\xD8W\x80`\x1F\x10a\x02\xAFWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02\xD8V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02\xBBW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x04\xD4\x91PPV[a\x03|\x85` \x80Ta\x02\xF7\x90a\x06\x19V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03#\x90a\x06\x19V[\x80\x15a\x03nW\x80`\x1F\x10a\x03EWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03nV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03QW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x05Q\x91PPV[a\x04\x12\x85` \x80Ta\x03\x8D\x90a\x06\x19V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xB9\x90a\x06\x19V[\x80\x15a\x04\x04W\x80`\x1F\x10a\x03\xDBWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x04\x04V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xE7W\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x05\xC4\x91PPV[`@Qa\x04\x1E\x90a\x05\xF8V[a\x04*\x93\x92\x91\x90a\x08\xB3V[`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x04CW=__>=_\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16a\x01\0`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x81\x02\x91\x90\x91\x17\x91\x82\x90U`@Qc\xF5\x8D\xB0o`\xE0\x1B\x81R`\x01`\x04\x82\x01\x81\x90R`$\x82\x01R\x91\x04\x90\x91\x16\x96Pc\xF5\x8D\xB0o\x95P`D\x01\x93Pa\x04\xA2\x92PPPV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xB9W__\xFD[PZ\xF1\x15\x80\x15a\x04\xCBW=__>=_\xFD[PPPPa\t\x12V[`@Qc\x1F\xB2C}`\xE3\x1B\x81R``\x90_Q` aW\n_9_Q\x90_R\x90c\xFD\x92\x1B\xE8\x90a\x05\t\x90\x86\x90\x86\x90`\x04\x01a\x08\xD7V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05#W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x05J\x91\x90\x81\x01\x90a\x07\xCCV[\x93\x92PPPV[`@QcV\xEE\xF1[`\xE1\x1B\x81R_\x90_Q` aW\n_9_Q\x90_R\x90c\xAD\xDD\xE2\xB6\x90a\x05\x85\x90\x86\x90\x86\x90`\x04\x01a\x08\xD7V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xA0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05J\x91\x90a\x08\xFBV[`@Qc\x17w\xE5\x9D`\xE0\x1B\x81R_\x90_Q` aW\n_9_Q\x90_R\x90c\x17w\xE5\x9D\x90a\x05\x85\x90\x86\x90\x86\x90`\x04\x01a\x08\xD7V[a);\x80a-\x7F\x839\x01\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x06-W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x06KWcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\x06\x98W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x06vWP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x06\x95W_\x81U`\x01\x01a\x06\x82V[PP[PPPV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x06\xB6Wa\x06\xB6a\x06\x05V[a\x06\xCA\x81a\x06\xC4\x84Ta\x06\x19V[\x84a\x06QV[` `\x1F\x82\x11`\x01\x81\x14a\x06\xFCW_\x83\x15a\x06\xE5WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x06\x95V[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x07+W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x07\x0BV[P\x84\x82\x10\x15a\x07HW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[_\x80`\x01`\x01`@\x1B\x03\x84\x11\x15a\x07pWa\x07pa\x06\x05V[P`@Q`\x1F\x19`\x1F\x85\x01\x81\x16`?\x01\x16\x81\x01\x81\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17\x15a\x07\x9EWa\x07\x9Ea\x06\x05V[`@R\x83\x81R\x90P\x80\x82\x84\x01\x85\x10\x15a\x07\xB5W__\xFD[\x83\x83` \x83\x01^_` \x85\x83\x01\x01RP\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x07\xDCW__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x07\xF1W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x08\x01W__\xFD[a\x08\x10\x84\x82Q` \x84\x01a\x07WV[\x94\x93PPPPV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x08:\x82\x85a\x08\x18V[\x7F/test/fullRelay/testData/\0\0\0\0\0\0\0\x81Ra\x08j`\x19\x82\x01\x85a\x08\x18V[\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R_a\x05J` \x83\x01\x84a\x08sV[``\x81R_a\x08\xC5``\x83\x01\x86a\x08sV[` \x83\x01\x94\x90\x94RP`@\x01R\x91\x90PV[`@\x81R_a\x08\xE9`@\x83\x01\x85a\x08sV[\x82\x81\x03` \x84\x01Ra\x08j\x81\x85a\x08sV[_` \x82\x84\x03\x12\x15a\t\x0BW__\xFD[PQ\x91\x90PV[a$`\x80a\t\x1F_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x84W_5`\xE0\x1C\x80c\x85\"l\x81\x11a\0\xDDW\x80c\xE2\x0C\x9Fq\x11a\0\x88W\x80c\xF1\x1D\\\xBC\x11a\0cW\x80c\xF1\x1D\\\xBC\x14a\x02\xCCW\x80c\xFAv&\xD4\x14a\x02\xD4W\x80c\xFA\xD0k\x8F\x14a\x02\xE1W__\xFD[\x80c\xE2\x0C\x9Fq\x14a\x02\xB4W\x80c\xE8\x9F\x84\x19\x14a\x02\xBCW\x80c\xF0\xC0\x83.\x14a\x02\xC4W__\xFD[\x80c\xB5+ X\x11a\0\xB8W\x80c\xB5+ X\x14a\x02\x8CW\x80c\xB5P\x8A\xA9\x14a\x02\x94W\x80c\xBAAO\xA6\x14a\x02\x9CW__\xFD[\x80c\x85\"l\x81\x14a\x02ZW\x80c\x91j\x17\xC6\x14a\x02oW\x80c\xB0FO\xDC\x14a\x02\x84W__\xFD[\x80c>^<#\x11a\x01=W\x80cd\x1E\x14M\x11a\x01\x18W\x80cd\x1E\x14M\x14a\x025W\x80cf\xD9\xA9\xA0\x14a\x02=W\x80ct\r\xBAt\x14a\x02RW__\xFD[\x80c>^<#\x14a\x02\x05W\x80c?r\x86\xF4\x14a\x02\rW\x80cD\xBA\xDB\xB6\x14a\x02\x15W__\xFD[\x80c\x1E\xD7\x83\x1C\x11a\x01mW\x80c\x1E\xD7\x83\x1C\x14a\x01\xD1W\x80c*\xDE8\x80\x14a\x01\xE6W\x80c9B_\x8F\x14a\x01\xFBW__\xFD[\x80c\x08\x13\x85*\x14a\x01\x88W\x80c\x1C\r\xA8\x1F\x14a\x01\xB1W[__\xFD[a\x01\x9Ba\x01\x966`\x04a\x1BVV[a\x02\xF4V[`@Qa\x01\xA8\x91\x90a\x1C\x0BV[`@Q\x80\x91\x03\x90\xF3[a\x01\xC4a\x01\xBF6`\x04a\x1BVV[a\x03?V[`@Qa\x01\xA8\x91\x90a\x1CnV[a\x01\xD9a\x03\xB1V[`@Qa\x01\xA8\x91\x90a\x1C\x80V[a\x01\xEEa\x04\x1EV[`@Qa\x01\xA8\x91\x90a\x1D2V[a\x02\x03a\x05gV[\0[a\x01\xD9a\x06\x92V[a\x01\xD9a\x06\xFDV[a\x02(a\x02#6`\x04a\x1BVV[a\x07hV[`@Qa\x01\xA8\x91\x90a\x1D\xB6V[a\x02\x03a\x07\xABV[a\x02Ea\x08\xCEV[`@Qa\x01\xA8\x91\x90a\x1EIV[a\x02\x03a\nGV[a\x02ba\x0B>V[`@Qa\x01\xA8\x91\x90a\x1E\xC7V[a\x02wa\x0C\tV[`@Qa\x01\xA8\x91\x90a\x1E\xD9V[a\x02wa\r\x0CV[a\x02\x03a\x0E\x0FV[a\x02ba\x0E]V[a\x02\xA4a\x0F(V[`@Q\x90\x15\x15\x81R` \x01a\x01\xA8V[a\x01\xD9a\x0F\xF8V[a\x02\x03a\x10cV[a\x02\x03a\x11\\V[a\x02\x03a\x12UV[`\x1FTa\x02\xA4\x90`\xFF\x16\x81V[a\x02(a\x02\xEF6`\x04a\x1BVV[a\x13\xDAV[``a\x037\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x14\x1DV[\x94\x93PPPPV[``_a\x03M\x85\x85\x85a\x02\xF4V[\x90P_[a\x03[\x85\x85a\x1F\x8AV[\x81\x10\x15a\x03\xA8W\x82\x82\x82\x81Q\x81\x10a\x03uWa\x03ua\x1F\x9DV[` \x02` \x01\x01Q`@Q` \x01a\x03\x8E\x92\x91\x90a\x1F\xE1V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x03QV[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x14W` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xE9W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05^W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x05GW\x83\x82\x90_R` _ \x01\x80Ta\x04\xBC\x90a\x1F\xF5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x04\xE8\x90a\x1F\xF5V[\x80\x15a\x053W\x80`\x1F\x10a\x05\nWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x053V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05\x16W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x04\x9FV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x04AV[PPPP\x90P\x90V[`@\x80Q\x80\x82\x01\x82R`\x1A\x81R\x7FInsufficient confirmations\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x05\xE8\x91\x90`\x04\x01a\x1CnV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05\xFFW__\xFD[PZ\xF1\x15\x80\x15a\x06\x11W=__>=_\xFD[PP`\x1FT`#T`$T`@Qb]\t\xA7`\xE4\x1B\x81Ra\x01\0\x90\x93\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x94Pc\x05\xD0\x9Ap\x93Pa\x06d\x92`!\x92`\"\x92\x90\x91`\t\x90`\x04\x01a!\x1BV[_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x06zW__\xFD[PZ\xFA\x15\x80\x15a\x06\x8CW=__>=_\xFD[PPPPV[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x14W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xE9WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x14W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xE9WPPPPP\x90P\x90V[``a\x037\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x15~V[`@\x80Q\x80\x82\x01\x82R`\x13\x81R\x7FBad inclusion proof\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x08,\x91\x90`\x04\x01a\x1CnV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08CW__\xFD[PZ\xF1\x15\x80\x15a\x08UW=__>=_\xFD[PPPP`\x1F`\x01\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\x05\xD0\x9Ap`!`\"`#T`$T`\x01a\x08\xAD\x91\x90a!`V[_`@Q\x86c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x06d\x95\x94\x93\x92\x91\x90a!\x1BV[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05^W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\t!\x90a\x1F\xF5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\tM\x90a\x1F\xF5V[\x80\x15a\t\x98W\x80`\x1F\x10a\toWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\t\x98V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t{W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\n/W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\t\xDCW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x08\xF1V[`@\x80Q\x80\x82\x01\x82R`\x13\x81R\x7FBad inclusion proof\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\n\xC8\x91\x90`\x04\x01a\x1CnV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\n\xDFW__\xFD[PZ\xF1\x15\x80\x15a\n\xF1W=__>=_\xFD[PP`\x1FT`$T`@Qb]\t\xA7`\xE4\x1B\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x93Pc\x05\xD0\x9Ap\x92Pa\x06d\x91`!\x91`\"\x91_\x90`\x04\x01a!sV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05^W\x83\x82\x90_R` _ \x01\x80Ta\x0B~\x90a\x1F\xF5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\xAA\x90a\x1F\xF5V[\x80\x15a\x0B\xF5W\x80`\x1F\x10a\x0B\xCCWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\xF5V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xD8W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0BaV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05^W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\xF4W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C\xA1W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0C,V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05^W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\xF7W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\xA4W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\r/V[`\x1FT`#T`$T`@Qb]\t\xA7`\xE4\x1B\x81Ra\x01\0\x90\x93\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92c\x05\xD0\x9Ap\x92a\x06d\x92`!\x92`\"\x92\x91\x90_\x90`\x04\x01a!\x1BV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05^W\x83\x82\x90_R` _ \x01\x80Ta\x0E\x9D\x90a\x1F\xF5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0E\xC9\x90a\x1F\xF5V[\x80\x15a\x0F\x14W\x80`\x1F\x10a\x0E\xEBWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F\x14V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0E\xF7W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0E\x80V[`\x08T_\x90`\xFF\x16\x15a\x0F?WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\xCDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xF1\x91\x90a!\xB8V[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x14W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xE9WPPPPP\x90P\x90V[`@\x80Q\x80\x82\x01\x82R`\x13\x81R\x7FBad inclusion proof\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x10\xE4\x91\x90`\x04\x01a\x1CnV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10\xFBW__\xFD[PZ\xF1\x15\x80\x15a\x11\rW=__>=_\xFD[PP`\x1FT`#T`$T`@Qb]\t\xA7`\xE4\x1B\x81Ra\x01\0\x90\x93\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x94Pc\x05\xD0\x9Ap\x93Pa\x06d\x92`!\x92\x91\x90_\x90`\x04\x01a!\xCFV[`@\x80Q\x80\x82\x01\x82R`\x16\x81R\x7FBad merkle array proof\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x11\xDD\x91\x90`\x04\x01a\x1CnV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x11\xF4W__\xFD[PZ\xF1\x15\x80\x15a\x12\x06W=__>=_\xFD[PP`\x1FT`#T`$T`@Qb]\t\xA7`\xE4\x1B\x81Ra\x01\0\x90\x93\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x94Pc\x05\xD0\x9Ap\x93Pa\x06d\x92`!\x92\x91\x90_\x90`\x04\x01a\"\x18V[`\x1FT`@Q\x7F\xF5\x8D\xB0o\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R_`\x04\x82\x01\x81\x90R`$\x82\x01Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90c\xF5\x8D\xB0o\x90`D\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12\xC8W__\xFD[PZ\xF1\x15\x80\x15a\x12\xDAW=__>=_\xFD[PP`@\x80Q\x80\x82\x01\x82R`\x1B\x81R\x7FGCD does not confirm header\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x93Pc\xF2\x8D\xCE\xB3\x92Pa\x13_\x91\x90`\x04\x01a\x1CnV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x13vW__\xFD[PZ\xF1\x15\x80\x15a\x13\x88W=__>=_\xFD[PP`\x1FT`#T`$T`@Qb]\t\xA7`\xE4\x1B\x81Ra\x01\0\x90\x93\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x94Pc\x05\xD0\x9Ap\x93Pa\x06d\x92`!\x92`\"\x92\x90\x91_\x90`\x04\x01a!\x1BV[``a\x037\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x16\xCCV[``a\x14)\x84\x84a\x1F\x8AV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x14AWa\x14Aa\x1A\xD1V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x14tW\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x14_W\x90P[P\x90P\x83[\x83\x81\x10\x15a\x15uWa\x15G\x86a\x14\x8E\x83a\x18\x1AV[\x85`@Q` \x01a\x14\xA1\x93\x92\x91\x90a\"aV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x14\xBD\x90a\x1F\xF5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x14\xE9\x90a\x1F\xF5V[\x80\x15a\x154W\x80`\x1F\x10a\x15\x0BWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x154V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15\x17W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x19K\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x15R\x87\x84a\x1F\x8AV[\x81Q\x81\x10a\x15bWa\x15ba\x1F\x9DV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x14yV[P\x94\x93PPPPV[``a\x15\x8A\x84\x84a\x1F\x8AV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x15\xA2Wa\x15\xA2a\x1A\xD1V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x15\xCBW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x15uWa\x16\x9E\x86a\x15\xE5\x83a\x18\x1AV[\x85`@Q` \x01a\x15\xF8\x93\x92\x91\x90a\"aV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x16\x14\x90a\x1F\xF5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x16@\x90a\x1F\xF5V[\x80\x15a\x16\x8BW\x80`\x1F\x10a\x16bWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x16\x8BV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x16nW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x19\xEA\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x16\xA9\x87\x84a\x1F\x8AV[\x81Q\x81\x10a\x16\xB9Wa\x16\xB9a\x1F\x9DV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x15\xD0V[``a\x16\xD8\x84\x84a\x1F\x8AV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\xF0Wa\x16\xF0a\x1A\xD1V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x17\x19W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x15uWa\x17\xEC\x86a\x173\x83a\x18\x1AV[\x85`@Q` \x01a\x17F\x93\x92\x91\x90a\"aV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x17b\x90a\x1F\xF5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x17\x8E\x90a\x1F\xF5V[\x80\x15a\x17\xD9W\x80`\x1F\x10a\x17\xB0Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x17\xD9V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x17\xBCW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x1A}\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x17\xF7\x87\x84a\x1F\x8AV[\x81Q\x81\x10a\x18\x07Wa\x18\x07a\x1F\x9DV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x17\x1EV[``\x81_\x03a\x18\\WPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x18\x85W\x80a\x18o\x81a\"\xFEV[\x91Pa\x18~\x90P`\n\x83a#bV[\x91Pa\x18_V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\x9FWa\x18\x9Fa\x1A\xD1V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x18\xC9W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x037Wa\x18\xDE`\x01\x83a\x1F\x8AV[\x91Pa\x18\xEB`\n\x86a#uV[a\x18\xF6\x90`0a!`V[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x19\x0BWa\x19\x0Ba\x1F\x9DV[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x19D`\n\x86a#bV[\x94Pa\x18\xCDV[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a\x19\xA0\x90\x86\x90\x86\x90`\x04\x01a#\x88V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x19\xBAW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x19\xE1\x91\x90\x81\x01\x90a#\xB5V[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x1A>\x90\x86\x90\x86\x90`\x04\x01a#\x88V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1AYW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x19\xE1\x91\x90a!\xB8V[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x1A>\x90\x86\x90\x86\x90`\x04\x01a#\x88V[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x1B'Wa\x1B'a\x1A\xD1V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x1BHWa\x1BHa\x1A\xD1V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x1BhW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1B~W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x1B\x8EW__\xFD[\x805a\x1B\xA1a\x1B\x9C\x82a\x1B/V[a\x1A\xFEV[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x1B\xB5W__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1CbW`?\x19\x87\x86\x03\x01\x84Ra\x1CM\x85\x83Qa\x1B\xDDV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1C1V[P\x92\x96\x95PPPPPPV[` \x81R_a\x19\xE1` \x83\x01\x84a\x1B\xDDV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1C\xCDW\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\x1C\x99V[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x1D&W`\x1F\x19\x85\x84\x03\x01\x88Ra\x1D\x10\x83\x83Qa\x1B\xDDV[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x1C\xF4V[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1CbW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1D\xA0`@\x87\x01\x82a\x1C\xD8V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1DXV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1C\xCDW\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1D\xCFV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x1E?W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x1D\xFFV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1CbW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x1E\x95`@\x88\x01\x82a\x1B\xDDV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x1E\xB0\x81\x83a\x1D\xEDV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1EoV[` \x81R_a\x19\xE1` \x83\x01\x84a\x1C\xD8V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1CbW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1FG`@\x87\x01\x82a\x1D\xEDV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1E\xFFV[\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\x19\xE4Wa\x19\xE4a\x1F]V[\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x037a\x1F\xEF\x83\x86a\x1F\xCAV[\x84a\x1F\xCAV[`\x01\x81\x81\x1C\x90\x82\x16\x80a \tW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a @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`\"`\x04R`$_\xFD[P\x91\x90PV[\x80T_\x90`\x01\x81\x81\x1C\x90\x82\x16\x80a ^W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a \x95W\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[\x81\x86R` \x86\x01\x81\x80\x15a \xB0W`\x01\x81\x14a \xE4Wa!\x10V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x85\x16\x82R\x83\x15\x15`\x05\x1B\x82\x01\x95Pa!\x10V[_\x87\x81R` \x90 _[\x85\x81\x10\x15a!\nW\x81T\x84\x82\x01R`\x01\x90\x91\x01\x90` \x01a \xEEV[\x83\x01\x96PP[PPPPP\x92\x91PPV[`\xA0\x81R_a!-`\xA0\x83\x01\x88a FV[\x82\x81\x03` \x84\x01Ra!?\x81\x88a FV[`@\x84\x01\x96\x90\x96RPP``\x81\x01\x92\x90\x92R`\xFF\x16`\x80\x90\x91\x01R\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x19\xE4Wa\x19\xE4a\x1F]V[`\xA0\x81R_a!\x85`\xA0\x83\x01\x87a FV[\x82\x81\x03` \x84\x01Ra!\x97\x81\x87a FV[\x91PP_`@\x83\x01R\x83``\x83\x01R`\xFF\x83\x16`\x80\x83\x01R\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a!\xC8W__\xFD[PQ\x91\x90PV[`\xA0\x81R_a!\xE1`\xA0\x83\x01\x87a FV[\x82\x81\x03` \x84\x01R` \x81R_` \x82\x01R`@\x81\x01\x91PP\x84`@\x83\x01R\x83``\x83\x01R`\xFF\x83\x16`\x80\x83\x01R\x95\x94PPPPPV[`\xA0\x81R_a\"*`\xA0\x83\x01\x87a FV[\x82\x81\x03` \x84\x01R`\x01\x81R_` \x82\x01R`@\x81\x01\x91PP\x84`@\x83\x01R\x83``\x83\x01R`\xFF\x83\x16`\x80\x83\x01R\x95\x94PPPPPV[\x7F.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R_a\"\x92`\x01\x83\x01\x86a\x1F\xCAV[\x7F[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\"\xC2`\x01\x82\x01\x86a\x1F\xCAV[\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\x81Ra\"\xF4`\x02\x82\x01\x85a\x1F\xCAV[\x96\x95PPPPPPV[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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#.Wa#.a\x1F]V[P`\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`\x12`\x04R`$_\xFD[_\x82a#pWa#pa#5V[P\x04\x90V[_\x82a#\x83Wa#\x83a#5V[P\x06\x90V[`@\x81R_a#\x9A`@\x83\x01\x85a\x1B\xDDV[\x82\x81\x03` \x84\x01Ra#\xAC\x81\x85a\x1B\xDDV[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a#\xC5W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a#\xDBW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a#\xEBW__\xFD[\x80Qa#\xF9a\x1B\x9C\x82a\x1B/V[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a$\rW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV\xFE\xA2dipfsX\"\x12 \xB9\xCD\x84\xEFk\xFF\x8D\xA1!u\xE3\x96\x1D\x9B\xC163/wO\xE1\x04\x0EQ\xF8\na\x9B\xA8\xB6{=dsolcC\0\x08\x1C\x003`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa);8\x03\x80a);\x839\x81\x01`@\x81\x90Ra\0.\x91a\x03+V[\x82\x82\x82\x82\x82\x82a\0?\x83Q`P\x14\x90V[a\0\x84W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x11`$\x82\x01RpBad genesis block`x\x1B`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\0\x8E\x84a\x01fV[\x90Pb\xFF\xFF\xFF\x82\x16\x15a\x01\tW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FPeriod start hash does not have `D\x82\x01R\x7Fwork. Hint: wrong byte order?\0\0\0`d\x82\x01R`\x84\x01a\0{V[_\x81\x81U`\x01\x82\x90U`\x02\x82\x90U\x81\x81R`\x04` R`@\x90 \x83\x90Ua\x012a\x07\xE0\x84a\x03\xFEV[a\x01<\x90\x84a\x04%V[_\x83\x81R`\x04` R`@\x90 Ua\x01S\x84a\x02&V[`\x05UPa\x05\xBD\x98PPPPPPPPPV[_`\x02\x80\x83`@Qa\x01x\x91\x90a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\x93W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x04NV[`@Q` \x01a\x01\xC8\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x01\xE2\x91a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\xFDW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02 \x91\x90a\x04NV[\x92\x91PPV[_a\x02 a\x023\x83a\x028V[a\x02CV[_a\x02 \x82\x82a\x02SV[_a\x02 a\xFF\xFF`\xD0\x1B\x83a\x02\xF7V[_\x80a\x02ja\x02c\x84`Ha\x04eV[\x85\x90a\x03\tV[`\xE8\x1C\x90P_\x84a\x02|\x85`Ka\x04eV[\x81Q\x81\x10a\x02\x8CWa\x02\x8Ca\x04xV[\x01` \x01Q`\xF8\x1C\x90P_a\x02\xBE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x02\xD1`\x03\x84a\x04\x8CV[`\xFF\x16\x90Pa\x02\xE2\x81a\x01\0a\x05\x88V[a\x02\xEC\x90\x83a\x05\x93V[\x97\x96PPPPPPPV[_a\x03\x02\x82\x84a\x05\xAAV[\x93\x92PPPV[_a\x03\x02\x83\x83\x01` \x01Q\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x03=W__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03RW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03bW__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03{Wa\x03{a\x03\x17V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x03\xA9Wa\x03\xA9a\x03\x17V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x03\xC0W__\xFD[\x81` \x84\x01` \x83\x01^_` \x92\x82\x01\x83\x01R\x90\x86\x01Q`@\x90\x96\x01Q\x90\x97\x95\x96P\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x04\x0CWa\x04\x0Ca\x03\xEAV[P\x06\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x04^W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02 Wa\x02 a\x04\x11V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[`\x01\x81[`\x01\x84\x11\x15a\x04\xE0W\x80\x85\x04\x81\x11\x15a\x04\xC4Wa\x04\xC4a\x04\x11V[`\x01\x84\x16\x15a\x04\xD2W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x04\xA9V[\x93P\x93\x91PPV[_\x82a\x04\xF6WP`\x01a\x02 V[\x81a\x05\x02WP_a\x02 V[\x81`\x01\x81\x14a\x05\x18W`\x02\x81\x14a\x05\"Wa\x05>V[`\x01\x91PPa\x02 V[`\xFF\x84\x11\x15a\x053Wa\x053a\x04\x11V[PP`\x01\x82\x1Ba\x02 V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x05aWP\x81\x81\na\x02 V[a\x05m_\x19\x84\x84a\x04\xA5V[\x80_\x19\x04\x82\x11\x15a\x05\x80Wa\x05\x80a\x04\x11V[\x02\x93\x92PPPV[_a\x03\x02\x83\x83a\x04\xE8V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x02 Wa\x02 a\x04\x11V[_\x82a\x05\xB8Wa\x05\xB8a\x03\xEAV[P\x04\x90V[a#q\x80a\x05\xCA_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\xADW\x80c\xB9\x85b\x1A\x11a\0}W\x80c\xE3\xD8\xD8\xD8\x11a\0cW\x80c\xE3\xD8\xD8\xD8\x14a\x02\"W\x80c\xE4q\xE7,\x14a\x02)W\x80c\xF5\x8D\xB0o\x14a\x02=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x13\x91\x90a!WV[`@Q` \x01a\x0C%\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\x90\x82\x90Ra\x0C]\x91a!AV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0CxW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x07\x91\x90a!WV[_\x83\x85\x14\x80\x15a\x0C\xAAWP\x82\x85\x14[\x15a\x0C\xB7WP`\x01a\x04\xF1V[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x0C\xFFW\x89\x83\x14a\x0C\xDEW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x0C\xF7W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x0C\xBDV[P\x82\x84\x03a\r\x13W_\x94PPPPPa\x04\xF1V[\x80\x82\x14a\r&W_\x94PPPPPa\x04\xF1V[P`\x01\x98\x97PPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\rYW_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\r9V[P\x80a\x05\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x80\x82\x81[a\r\xB8`\x04`\x01a!\x9BV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0E\x0CW_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\r\xF1W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0E\x04V[a\r\xFB\x81\x84a!\xB7V[\x95\x94PPPPPV[`\x01\x01a\r\xACV[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_`P\x82Qa\x0B~\x91\x90a!.V[__a\x0Eo\x85a\x0B\xC3V[\x90P_a\x0E{\x82a\r\xA7V[\x90P_a\x0E\x87\x86a\x19\xE6V[\x90P\x84\x80a\x0E\x9CWP\x80a\x0E\x9A\x88a\x19\xE6V[\x14[a\x0F\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x03.V[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x12\x0EWa\x0F(`P\x82a!\xCAV[a\x0F3\x90`\x01a!\xB7V[a\x0F=\x90\x87a!\xB7V[\x93Pa\x0FK\x8A\x82`Pa\x19\xF1V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x11!W\x84a\x10\xA1\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x10\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x11\n`\x04\x85a!.V[_\x03a\x11!W_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x11,\x8B\x83a\x1A\x16V[\x14a\x11yW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[\x86a\x11\x84\x8B\x83a\x1A\xAFV[\x14a\x11\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x03.V[\x82\x96P`P\x81a\x12\x07\x91\x90a!\xB7V[\x90Pa\x0F\x15V[P\x81a\x12\x19\x8Ba\x0B\xC3V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x12\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x12\xD4\x84a\x0B\xC3V[\x90P_a\x12\xE0\x86a\x0B\xC3V[\x90P`\x01T\x81\x14a\x133W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x03.V[_\x82\x81R`\x03` R`@\x90 Ta\x13\x8DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x13\x9B\x87`\x01T\x84\x87a\x0C\x9BV[a\x14\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x03.V[\x81a\x14\x19\x88\x88\x88a\x17\x80V[\x14a\x14\x8CW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[`\x01\x82\x90U`\x02\x87\x90U_a\x14\xA0\x86a\x1A\xC7V[\x90P`\x05T\x81\x14a\x14\xB1W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x15\x01a\x14\xFC\x86a\x0B\xC3V[a\r\xA7V[\x90P_a\x15\x10a\x14\xFC\x86a\x0B\xC3V[\x90Pa\x15\x1Ea\x07\xE0\x82a!.V[a\x07\xDF\x14a\x15\x94W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x03.V[a\x15\xA0\x82a\x07\xDFa!\xB7V[\x81\x14a\x16\x14W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x03.V[a\x16\x1D\x85a\x1A\xC7V[a\x16&\x87a\x1A\xC7V[\x14a\x16\x99W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x03.V[_a\x16\xA3\x85a\x19\xE6V[\x90P_a\x16\xD5a\x16\xB2\x89a\x19\xE6V[a\x16\xBB\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x16\xCA\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x1B\x0CV[\x90P\x81\x81\x83\x16\x14a\x17(W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_a\x172\x89a\x1A\xC7V[\x90P\x80`\x06T\x14\x15\x80\x15a\x17\\WPa\x07\xE0a\x17O`\x01Ta\r\xA7V[a\x17Y\x91\x90a!\xDDV[\x84\x11[\x15a\x17gW`\x06\x81\x90U[a\x17s\x88\x88`\x01a\x0EdV[\x99\x98PPPPPPPPPV[__a\x17\x8B\x85a\r\xA7V[\x90P_a\x17\x9Aa\x14\xFC\x86a\x0B\xC3V[\x90P_a\x17\xA9a\x14\xFC\x86a\x0B\xC3V[\x90P\x82\x82\x10\x15\x80\x15a\x17\xBBWP\x82\x81\x10\x15[a\x18-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x18:a\x07\xE0\x85a!.V[a\x18F\x85a\x07\xE0a!\xB7V[a\x18P\x91\x90a!\xDDV[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x18bWP\x80[\x15a\x18}Wa\x18p\x89a\x0B\xC3V[\x96PPPPPPPa\n\xA3V[\x81\x80\x15a\x18\x88WP\x80\x15[\x15a\x18\x96Wa\x18p\x88a\x0B\xC3V[\x81\x80\x15a\x18\xA0WP\x80[\x15a\x18\xC4W\x83\x85\x10\x15a\x18\xBBWa\x18\xB6\x88a\x0B\xC3V[a\x18pV[a\x18p\x89a\x0B\xC3V[a\x18\xCD\x88a\x1A\xC7V[a\x18\xD9a\x07\xE0\x86a!.V[a\x18\xE3\x91\x90a!\xF0V[a\x18\xEC\x8Aa\x1A\xC7V[a\x18\xF8a\x07\xE0\x88a!.V[a\x19\x02\x91\x90a!\xF0V[\x10\x15a\x18\xBBWa\x18p\x88a\x0B\xC3V[`\x07T_\x90`\xFF\x16\x15a\x19/WP`\x07Ta\x01\0\x90\x04`\xFF\x16a\n\xA3V[a\x19:\x84\x84\x84a\x1B\x94V[\x90Pa\n\xA3V[_` \x84Qa\x19P\x91\x90a!.V[\x15a\x19\\WP_a\x04\xF1V[\x83Q_\x03a\x19kWP_a\x04\xF1V[\x81\x85_[\x86Q\x81\x10\x15a\x19\xD9Wa\x19\x83`\x02\x84a!.V[`\x01\x03a\x19\xA7Wa\x19\xA0a\x19\x9A\x88\x83\x01` \x01Q\x90V[\x83a\x1B\xD5V[\x91Pa\x19\xC0V[a\x19\xBD\x82a\x19\xB8\x89\x84\x01` \x01Q\x90V[a\x1B\xD5V[\x91P[`\x01\x92\x90\x92\x1C\x91a\x19\xD2` \x82a!\xB7V[\x90Pa\x19oV[P\x90\x93\x14\x95\x94PPPPPV[_a\x05\x07\x82_a\x1A\x16V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x1A-a\x1A&\x84`Ha!\xB7V[\x85\x90a\x1B\xE0V[`\xE8\x1C\x90P_\x84a\x1A?\x85`Ka!\xB7V[\x81Q\x81\x10a\x1AOWa\x1AOa\"\x07V[\x01` \x01Q`\xF8\x1C\x90P_a\x1A\x81\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1A\x94`\x03\x84a\"4V[`\xFF\x16\x90Pa\x1A\xA5\x81a\x01\0a#0V[a\x08-\x90\x83a!\xF0V[_a\x05\x04a\x1A\xBE\x83`\x04a!\xB7V[\x84\x01` \x01Q\x90V[_a\x05\x07a\x1A\xD4\x83a\x19\xE6V[a\x1B\xEEV[_a\x05\x07a\x1A\xE6\x83a\x1C\x15V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1B\x18\x83\x85a\x1C!V[\x90Pa\x1B(b\x12u\0`\x04a\x1C|V[\x81\x10\x15a\x1B@Wa\x1B=b\x12u\0`\x04a\x1C|V[\x90P[a\x1BNb\x12u\0`\x04a\x1C\x87V[\x81\x11\x15a\x1BfWa\x1Bcb\x12u\0`\x04a\x1C\x87V[\x90P[_a\x1B~\x82a\x1Bx\x88b\x01\0\0a\x1C|V[\x90a\x1C\x87V[\x90Pa\n\x8Ab\x01\0\0a\x1Bx\x83b\x12u\0a\x1C|V[_\x82\x81[\x83\x81\x10\x15a\x1B\xCAW\x85\x82\x03a\x1B\xB2W`\x01\x92PPPa\n\xA3V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x1B\x98V[P_\x95\x94PPPPPV[_a\x05\x04\x83\x83a\x1C\xFAV[_a\x05\x04\x83\x83\x01` \x01Q\x90V[_a\x05\x07{\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\x83a\x1C|V[_a\x05\x07\x82`Da\x1B\xE0V[_\x82\x82\x11\x15a\x1CrW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x05\x04\x82\x84a!\xDDV[_a\x05\x04\x82\x84a!\xCAV[_\x82_\x03a\x1C\x96WP_a\x05\x07V[a\x1C\xA0\x82\x84a!\xF0V[\x90P\x81a\x1C\xAD\x84\x83a!\xCAV[\x14a\x05\x07W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x03.V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1D1W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DHW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1D_W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1DvW__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1D\x91W__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xA7W__\xFD[a\x1D\xB3\x8A\x82\x8B\x01a\x1D!V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xD2W__\xFD[a\x1D\xDE\x8A\x82\x8B\x01a\x1D!V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1D\xFE`\x80\x89\x01a\x1DfV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[____`\x80\x85\x87\x03\x12\x15a\x1E\x1FW__\xFD[PP\x825\x94` \x84\x015\x94P`@\x84\x015\x93``\x015\x92P\x90PV[__`@\x83\x85\x03\x12\x15a\x1ELW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1EkW__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1E\x85W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x9BW__\xFD[a\x1E\xA7\x87\x82\x88\x01a\x1D!V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\xC6W__\xFD[a\x1E\xD2\x87\x82\x88\x01a\x1D!V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1E\xF3W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x10W__\xFD[a\x1F\x1C\x89\x82\x8A\x01a\x1D!V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F;W__\xFD[a\x1FG\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1FtW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x8AW__\xFD[a\x1F\x96\x89\x82\x8A\x01a\x1D!V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xB5W__\xFD[a\x1F\xC1\x89\x82\x8A\x01a\x1D!V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xE0W__\xFD[a\x1F\xEC\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_____``\x86\x88\x03\x12\x15a \x12W__\xFD[\x855\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a /W__\xFD[a ;\x88\x82\x89\x01a\x1D!V[\x90\x95P\x93PP`@\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a ZW__\xFD[a f\x88\x82\x89\x01a\x1D!V[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[___``\x84\x86\x03\x12\x15a \x89W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a \xB1W__\xFD[\x825\x91Pa \xC1` \x84\x01a\x1DfV[\x90P\x92P\x92\x90PV[\x805\x80\x15\x15\x81\x14a\x1DvW__\xFD[__`@\x83\x85\x03\x12\x15a \xEAW__\xFD[a \xF3\x83a \xCAV[\x91Pa \xC1` \x84\x01a \xCAV[\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!\xA9m\xA5\xCFi_\"\xBF}\x94\xBE\x87\xD4\x9D\xB1\xADz\xC3q\xACC\xC4\xDAAa\xC8\xC2\x164\x9C[\xA1\x19(\x17\r8x+\0\0\0\0\0\0\0\0\0\0\0\0q\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\xE3Z\rm\xE9Kef\x94X\x99d\xA2R\x95~Fs\xA9\xFB\x1D/\x8BJ\x92\xE3\xF0\xA7\xBBeO\xDD\xB9NZ\x1Em\x7F\x7FI\x9F\xD1\xBE]\xD3\ns\xBFU\x84\xBF\x13}\xA5\xFD\xD7|\xC2\x1A\xEB\x95\xB9\xE3W\x88\x89K\xE0\x19(K\xD4\xFB\xEDm\xD6\x11\x8A\xC2\xCBm&\xBCK\xE4\xE4#\xF5Z:H\xF2\x87M\x8D\x02\xA6]\x9C\x87\xD0}\xE2\x1DM\xFE{\n\x9FJ#\xCC\x9AX7>\x9Ei1\xFE\xFD\xB5\xAF\xAD\xE5\xDFT\xC9\x11\x04\x04\x8D\xF1\xEE\x99\x92@ay\x84\xE1\x8Bo\x93\x1E#sg=\x01\x95\xB8\xC6\x98}\x7F\xF7e\r\\\xE5;\xCE\xC4n\x13\xABO-\xA1\x14j\x7F\xC6!\xEEg/b\xBC\"t$\x869-u\xE5^g\xB0\x99`\xC38j\x0BI\xE7_\x17#\xD6\xAB(\xAC\x9A (\xA0\xC7(f\xE2\x11\x1Dy\xD4\x81{\x88\xE1|\x82\x197\x84wh\xD9(7\xBA\xE3\x83+\xB8\xE5\xA4\xABD4\xB9~\0\xA6\xC1\x01\x82\xF2\x11\xF5\x92@\x90h\xD6\xF5e$\0\xD9\xA3\xD1\xCC\x15\n\x7F\xB6\x92\xE8t\xCCB\xD7k\xDA\xFC\x84//\xE0\xF85\xA7\xC2M-`\xC1\t\xB1\x87\xD6Eq\xEF\xBA\xA8\x04{\xE8X!\xF8\xE6~\x0E\x85\xF2\xF5\x89K\xC6=\0\xC2\xED\x9Dd", - ); - /// The runtime bytecode of the contract, as deployed on the network. - /// - /// ```text - ///0x608060405234801561000f575f5ffd5b5060043610610184575f3560e01c806385226c81116100dd578063e20c9f7111610088578063f11d5cbc11610063578063f11d5cbc146102cc578063fa7626d4146102d4578063fad06b8f146102e1575f5ffd5b8063e20c9f71146102b4578063e89f8419146102bc578063f0c0832e146102c4575f5ffd5b8063b52b2058116100b8578063b52b20581461028c578063b5508aa914610294578063ba414fa61461029c575f5ffd5b806385226c811461025a578063916a17c61461026f578063b0464fdc14610284575f5ffd5b80633e5e3c231161013d578063641e144d11610118578063641e144d1461023557806366d9a9a01461023d578063740dba7414610252575f5ffd5b80633e5e3c23146102055780633f7286f41461020d57806344badbb614610215575f5ffd5b80631ed7831c1161016d5780631ed7831c146101d15780632ade3880146101e657806339425f8f146101fb575f5ffd5b80630813852a146101885780631c0da81f146101b1575b5f5ffd5b61019b610196366004611b56565b6102f4565b6040516101a89190611c0b565b60405180910390f35b6101c46101bf366004611b56565b61033f565b6040516101a89190611c6e565b6101d96103b1565b6040516101a89190611c80565b6101ee61041e565b6040516101a89190611d32565b610203610567565b005b6101d9610692565b6101d96106fd565b610228610223366004611b56565b610768565b6040516101a89190611db6565b6102036107ab565b6102456108ce565b6040516101a89190611e49565b610203610a47565b610262610b3e565b6040516101a89190611ec7565b610277610c09565b6040516101a89190611ed9565b610277610d0c565b610203610e0f565b610262610e5d565b6102a4610f28565b60405190151581526020016101a8565b6101d9610ff8565b610203611063565b61020361115c565b610203611255565b601f546102a49060ff1681565b6102286102ef366004611b56565b6113da565b60606103378484846040518060400160405280600381526020017f686578000000000000000000000000000000000000000000000000000000000081525061141d565b949350505050565b60605f61034d8585856102f4565b90505f5b61035b8585611f8a565b8110156103a8578282828151811061037557610375611f9d565b602002602001015160405160200161038e929190611fe1565b60408051601f198184030181529190529250600101610351565b50509392505050565b6060601680548060200260200160405190810160405280929190818152602001828054801561041457602002820191905f5260205f20905b815473ffffffffffffffffffffffffffffffffffffffff1681526001909101906020018083116103e9575b5050505050905090565b6060601e805480602002602001604051908101604052809291908181526020015f905b8282101561055e575f848152602080822060408051808201825260028702909201805473ffffffffffffffffffffffffffffffffffffffff168352600181018054835181870281018701909452808452939591948681019491929084015b82821015610547578382905f5260205f200180546104bc90611ff5565b80601f01602080910402602001604051908101604052809291908181526020018280546104e890611ff5565b80156105335780601f1061050a57610100808354040283529160200191610533565b820191905f5260205f20905b81548152906001019060200180831161051657829003601f168201915b50505050508152602001906001019061049f565b505050508152505081526020019060010190610441565b50505050905090565b604080518082018252601a81527f496e73756666696369656e7420636f6e6669726d6174696f6e73000000000000602082015290517ff28dceb3000000000000000000000000000000000000000000000000000000008152737109709ecfa91a80626ff3989d68f67f5b1dd12d9163f28dceb3916105e89190600401611c6e565b5f604051808303815f87803b1580156105ff575f5ffd5b505af1158015610611573d5f5f3e3d5ffd5b5050601f54602354602454604051625d09a760e41b815261010090930473ffffffffffffffffffffffffffffffffffffffff1694506305d09a70935061066492602192602292909160099060040161211b565b5f6040518083038186803b15801561067a575f5ffd5b505afa15801561068c573d5f5f3e3d5ffd5b50505050565b6060601880548060200260200160405190810160405280929190818152602001828054801561041457602002820191905f5260205f2090815473ffffffffffffffffffffffffffffffffffffffff1681526001909101906020018083116103e9575050505050905090565b6060601780548060200260200160405190810160405280929190818152602001828054801561041457602002820191905f5260205f2090815473ffffffffffffffffffffffffffffffffffffffff1681526001909101906020018083116103e9575050505050905090565b60606103378484846040518060400160405280600981526020017f6469676573745f6c65000000000000000000000000000000000000000000000081525061157e565b604080518082018252601381527f42616420696e636c7573696f6e2070726f6f6600000000000000000000000000602082015290517ff28dceb3000000000000000000000000000000000000000000000000000000008152737109709ecfa91a80626ff3989d68f67f5b1dd12d9163f28dceb39161082c9190600401611c6e565b5f604051808303815f87803b158015610843575f5ffd5b505af1158015610855573d5f5f3e3d5ffd5b50505050601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166305d09a706021602260235460245460016108ad9190612160565b5f6040518663ffffffff1660e01b815260040161066495949392919061211b565b6060601b805480602002602001604051908101604052809291908181526020015f905b8282101561055e578382905f5260205f2090600202016040518060400160405290815f8201805461092190611ff5565b80601f016020809104026020016040519081016040528092919081815260200182805461094d90611ff5565b80156109985780601f1061096f57610100808354040283529160200191610998565b820191905f5260205f20905b81548152906001019060200180831161097b57829003601f168201915b5050505050815260200160018201805480602002602001604051908101604052809291908181526020018280548015610a2f57602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916815260200190600401906020826003010492830192600103820291508084116109dc5790505b505050505081525050815260200190600101906108f1565b604080518082018252601381527f42616420696e636c7573696f6e2070726f6f6600000000000000000000000000602082015290517ff28dceb3000000000000000000000000000000000000000000000000000000008152737109709ecfa91a80626ff3989d68f67f5b1dd12d9163f28dceb391610ac89190600401611c6e565b5f604051808303815f87803b158015610adf575f5ffd5b505af1158015610af1573d5f5f3e3d5ffd5b5050601f54602454604051625d09a760e41b815261010090920473ffffffffffffffffffffffffffffffffffffffff1693506305d09a709250610664916021916022915f90600401612173565b6060601a805480602002602001604051908101604052809291908181526020015f905b8282101561055e578382905f5260205f20018054610b7e90611ff5565b80601f0160208091040260200160405190810160405280929190818152602001828054610baa90611ff5565b8015610bf55780601f10610bcc57610100808354040283529160200191610bf5565b820191905f5260205f20905b815481529060010190602001808311610bd857829003601f168201915b505050505081526020019060010190610b61565b6060601d805480602002602001604051908101604052809291908181526020015f905b8282101561055e575f84815260209081902060408051808201825260028602909201805473ffffffffffffffffffffffffffffffffffffffff168352600181018054835181870281018701909452808452939491938583019392830182828015610cf457602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191681526020019060040190602082600301049283019260010382029150808411610ca15790505b50505050508152505081526020019060010190610c2c565b6060601c805480602002602001604051908101604052809291908181526020015f905b8282101561055e575f84815260209081902060408051808201825260028602909201805473ffffffffffffffffffffffffffffffffffffffff168352600181018054835181870281018701909452808452939491938583019392830182828015610df757602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191681526020019060040190602082600301049283019260010382029150808411610da45790505b50505050508152505081526020019060010190610d2f565b601f54602354602454604051625d09a760e41b815261010090930473ffffffffffffffffffffffffffffffffffffffff16926305d09a70926106649260219260229291905f9060040161211b565b60606019805480602002602001604051908101604052809291908181526020015f905b8282101561055e578382905f5260205f20018054610e9d90611ff5565b80601f0160208091040260200160405190810160405280929190818152602001828054610ec990611ff5565b8015610f145780601f10610eeb57610100808354040283529160200191610f14565b820191905f5260205f20905b815481529060010190602001808311610ef757829003601f168201915b505050505081526020019060010190610e80565b6008545f9060ff1615610f3f575060085460ff1690565b6040517f667f9d70000000000000000000000000000000000000000000000000000000008152737109709ecfa91a80626ff3989d68f67f5b1dd12d600482018190527f6661696c6564000000000000000000000000000000000000000000000000000060248301525f9163667f9d7090604401602060405180830381865afa158015610fcd573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610ff191906121b8565b1415905090565b6060601580548060200260200160405190810160405280929190818152602001828054801561041457602002820191905f5260205f2090815473ffffffffffffffffffffffffffffffffffffffff1681526001909101906020018083116103e9575050505050905090565b604080518082018252601381527f42616420696e636c7573696f6e2070726f6f6600000000000000000000000000602082015290517ff28dceb3000000000000000000000000000000000000000000000000000000008152737109709ecfa91a80626ff3989d68f67f5b1dd12d9163f28dceb3916110e49190600401611c6e565b5f604051808303815f87803b1580156110fb575f5ffd5b505af115801561110d573d5f5f3e3d5ffd5b5050601f54602354602454604051625d09a760e41b815261010090930473ffffffffffffffffffffffffffffffffffffffff1694506305d09a7093506106649260219291905f906004016121cf565b604080518082018252601681527f426164206d65726b6c652061727261792070726f6f6600000000000000000000602082015290517ff28dceb3000000000000000000000000000000000000000000000000000000008152737109709ecfa91a80626ff3989d68f67f5b1dd12d9163f28dceb3916111dd9190600401611c6e565b5f604051808303815f87803b1580156111f4575f5ffd5b505af1158015611206573d5f5f3e3d5ffd5b5050601f54602354602454604051625d09a760e41b815261010090930473ffffffffffffffffffffffffffffffffffffffff1694506305d09a7093506106649260219291905f90600401612218565b601f546040517ff58db06f0000000000000000000000000000000000000000000000000000000081525f60048201819052602482015261010090910473ffffffffffffffffffffffffffffffffffffffff169063f58db06f906044015f604051808303815f87803b1580156112c8575f5ffd5b505af11580156112da573d5f5f3e3d5ffd5b5050604080518082018252601b81527f47434420646f6573206e6f7420636f6e6669726d206865616465720000000000602082015290517ff28dceb3000000000000000000000000000000000000000000000000000000008152737109709ecfa91a80626ff3989d68f67f5b1dd12d935063f28dceb3925061135f9190600401611c6e565b5f604051808303815f87803b158015611376575f5ffd5b505af1158015611388573d5f5f3e3d5ffd5b5050601f54602354602454604051625d09a760e41b815261010090930473ffffffffffffffffffffffffffffffffffffffff1694506305d09a7093506106649260219260229290915f9060040161211b565b60606103378484846040518060400160405280600681526020017f68656967687400000000000000000000000000000000000000000000000000008152506116cc565b60606114298484611f8a565b67ffffffffffffffff81111561144157611441611ad1565b60405190808252806020026020018201604052801561147457816020015b606081526020019060019003908161145f5790505b509050835b83811015611575576115478661148e8361181a565b856040516020016114a193929190612261565b604051602081830303815290604052602080546114bd90611ff5565b80601f01602080910402602001604051908101604052809291908181526020018280546114e990611ff5565b80156115345780601f1061150b57610100808354040283529160200191611534565b820191905f5260205f20905b81548152906001019060200180831161151757829003601f168201915b505050505061194b90919063ffffffff16565b826115528784611f8a565b8151811061156257611562611f9d565b6020908102919091010152600101611479565b50949350505050565b606061158a8484611f8a565b67ffffffffffffffff8111156115a2576115a2611ad1565b6040519080825280602002602001820160405280156115cb578160200160208202803683370190505b509050835b838110156115755761169e866115e58361181a565b856040516020016115f893929190612261565b6040516020818303038152906040526020805461161490611ff5565b80601f016020809104026020016040519081016040528092919081815260200182805461164090611ff5565b801561168b5780601f106116625761010080835404028352916020019161168b565b820191905f5260205f20905b81548152906001019060200180831161166e57829003601f168201915b50505050506119ea90919063ffffffff16565b826116a98784611f8a565b815181106116b9576116b9611f9d565b60209081029190910101526001016115d0565b60606116d88484611f8a565b67ffffffffffffffff8111156116f0576116f0611ad1565b604051908082528060200260200182016040528015611719578160200160208202803683370190505b509050835b83811015611575576117ec866117338361181a565b8560405160200161174693929190612261565b6040516020818303038152906040526020805461176290611ff5565b80601f016020809104026020016040519081016040528092919081815260200182805461178e90611ff5565b80156117d95780601f106117b0576101008083540402835291602001916117d9565b820191905f5260205f20905b8154815290600101906020018083116117bc57829003601f168201915b5050505050611a7d90919063ffffffff16565b826117f78784611f8a565b8151811061180757611807611f9d565b602090810291909101015260010161171e565b6060815f0361185c57505060408051808201909152600181527f3000000000000000000000000000000000000000000000000000000000000000602082015290565b815f5b8115611885578061186f816122fe565b915061187e9050600a83612362565b915061185f565b5f8167ffffffffffffffff81111561189f5761189f611ad1565b6040519080825280601f01601f1916602001820160405280156118c9576020820181803683370190505b5090505b8415610337576118de600183611f8a565b91506118eb600a86612375565b6118f6906030612160565b60f81b81838151811061190b5761190b611f9d565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff191690815f1a905350611944600a86612362565b94506118cd565b6040517ffd921be8000000000000000000000000000000000000000000000000000000008152606090737109709ecfa91a80626ff3989d68f67f5b1dd12d9063fd921be8906119a09086908690600401612388565b5f60405180830381865afa1580156119ba573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d908101601f191682016040526119e191908101906123b5565b90505b92915050565b6040517f1777e59d0000000000000000000000000000000000000000000000000000000081525f90737109709ecfa91a80626ff3989d68f67f5b1dd12d90631777e59d90611a3e9086908690600401612388565b602060405180830381865afa158015611a59573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906119e191906121b8565b6040517faddde2b60000000000000000000000000000000000000000000000000000000081525f90737109709ecfa91a80626ff3989d68f67f5b1dd12d9063addde2b690611a3e9086908690600401612388565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b604051601f8201601f1916810167ffffffffffffffff81118282101715611b2757611b27611ad1565b604052919050565b5f67ffffffffffffffff821115611b4857611b48611ad1565b50601f01601f191660200190565b5f5f5f60608486031215611b68575f5ffd5b833567ffffffffffffffff811115611b7e575f5ffd5b8401601f81018613611b8e575f5ffd5b8035611ba1611b9c82611b2f565b611afe565b818152876020838501011115611bb5575f5ffd5b816020840160208301375f602092820183015297908601359650604090950135949350505050565b5f81518084528060208401602086015e5f602082860101526020601f19601f83011685010191505092915050565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b82811015611c6257603f19878603018452611c4d858351611bdd565b94506020938401939190910190600101611c31565b50929695505050505050565b602081525f6119e16020830184611bdd565b602080825282518282018190525f918401906040840190835b81811015611ccd57835173ffffffffffffffffffffffffffffffffffffffff16835260209384019390920191600101611c99565b509095945050505050565b5f82825180855260208501945060208160051b830101602085015f5b83811015611d2657601f19858403018852611d10838351611bdd565b6020988901989093509190910190600101611cf4565b50909695505050505050565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b82811015611c6257603f19878603018452815173ffffffffffffffffffffffffffffffffffffffff81511686526020810151905060406020870152611da06040870182611cd8565b9550506020938401939190910190600101611d58565b602080825282518282018190525f918401906040840190835b81811015611ccd578351835260209384019390920191600101611dcf565b5f8151808452602084019350602083015f5b82811015611e3f5781517fffffffff0000000000000000000000000000000000000000000000000000000016865260209586019590910190600101611dff565b5093949350505050565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b82811015611c6257603f198786030184528151805160408752611e956040880182611bdd565b9050602082015191508681036020880152611eb08183611ded565b965050506020938401939190910190600101611e6f565b602081525f6119e16020830184611cd8565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b82811015611c6257603f19878603018452815173ffffffffffffffffffffffffffffffffffffffff81511686526020810151905060406020870152611f476040870182611ded565b9550506020938401939190910190600101611eff565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b818103818111156119e4576119e4611f5d565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b5f81518060208401855e5f93019283525090919050565b5f610337611fef8386611fca565b84611fca565b600181811c9082168061200957607f821691505b602082108103612040577f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b50919050565b80545f90600181811c9082168061205e57607f821691505b602082108103612095577f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b818652602086018180156120b057600181146120e457612110565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff008516825283151560051b82019550612110565b5f878152602090205f5b8581101561210a578154848201526001909101906020016120ee565b83019650505b505050505092915050565b60a081525f61212d60a0830188612046565b828103602084015261213f8188612046565b60408401969096525050606081019290925260ff1660809091015292915050565b808201808211156119e4576119e4611f5d565b60a081525f61218560a0830187612046565b82810360208401526121978187612046565b9150505f604083015283606083015260ff8316608083015295945050505050565b5f602082840312156121c8575f5ffd5b5051919050565b60a081525f6121e160a0830187612046565b8281036020840152602081525f60208201526040810191505084604083015283606083015260ff8316608083015295945050505050565b60a081525f61222a60a0830187612046565b8281036020840152600181525f60208201526040810191505084604083015283606083015260ff8316608083015295945050505050565b7f2e0000000000000000000000000000000000000000000000000000000000000081525f6122926001830186611fca565b7f5b0000000000000000000000000000000000000000000000000000000000000081526122c26001820186611fca565b90507f5d2e00000000000000000000000000000000000000000000000000000000000081526122f46002820185611fca565b9695505050505050565b5f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff820361232e5761232e611f5d565b5060010190565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b5f8261237057612370612335565b500490565b5f8261238357612383612335565b500690565b604081525f61239a6040830185611bdd565b82810360208401526123ac8185611bdd565b95945050505050565b5f602082840312156123c5575f5ffd5b815167ffffffffffffffff8111156123db575f5ffd5b8201601f810184136123eb575f5ffd5b80516123f9611b9c82611b2f565b81815285602083850101111561240d575f5ffd5b8160208401602083015e5f9181016020019190915294935050505056fea2646970667358221220b9cd84ef6bff8da12175e3961d9bc136332f774fe1040e51f80a619ba8b67b3d64736f6c634300081c0033 - /// ``` - #[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\x01\x84W_5`\xE0\x1C\x80c\x85\"l\x81\x11a\0\xDDW\x80c\xE2\x0C\x9Fq\x11a\0\x88W\x80c\xF1\x1D\\\xBC\x11a\0cW\x80c\xF1\x1D\\\xBC\x14a\x02\xCCW\x80c\xFAv&\xD4\x14a\x02\xD4W\x80c\xFA\xD0k\x8F\x14a\x02\xE1W__\xFD[\x80c\xE2\x0C\x9Fq\x14a\x02\xB4W\x80c\xE8\x9F\x84\x19\x14a\x02\xBCW\x80c\xF0\xC0\x83.\x14a\x02\xC4W__\xFD[\x80c\xB5+ X\x11a\0\xB8W\x80c\xB5+ X\x14a\x02\x8CW\x80c\xB5P\x8A\xA9\x14a\x02\x94W\x80c\xBAAO\xA6\x14a\x02\x9CW__\xFD[\x80c\x85\"l\x81\x14a\x02ZW\x80c\x91j\x17\xC6\x14a\x02oW\x80c\xB0FO\xDC\x14a\x02\x84W__\xFD[\x80c>^<#\x11a\x01=W\x80cd\x1E\x14M\x11a\x01\x18W\x80cd\x1E\x14M\x14a\x025W\x80cf\xD9\xA9\xA0\x14a\x02=W\x80ct\r\xBAt\x14a\x02RW__\xFD[\x80c>^<#\x14a\x02\x05W\x80c?r\x86\xF4\x14a\x02\rW\x80cD\xBA\xDB\xB6\x14a\x02\x15W__\xFD[\x80c\x1E\xD7\x83\x1C\x11a\x01mW\x80c\x1E\xD7\x83\x1C\x14a\x01\xD1W\x80c*\xDE8\x80\x14a\x01\xE6W\x80c9B_\x8F\x14a\x01\xFBW__\xFD[\x80c\x08\x13\x85*\x14a\x01\x88W\x80c\x1C\r\xA8\x1F\x14a\x01\xB1W[__\xFD[a\x01\x9Ba\x01\x966`\x04a\x1BVV[a\x02\xF4V[`@Qa\x01\xA8\x91\x90a\x1C\x0BV[`@Q\x80\x91\x03\x90\xF3[a\x01\xC4a\x01\xBF6`\x04a\x1BVV[a\x03?V[`@Qa\x01\xA8\x91\x90a\x1CnV[a\x01\xD9a\x03\xB1V[`@Qa\x01\xA8\x91\x90a\x1C\x80V[a\x01\xEEa\x04\x1EV[`@Qa\x01\xA8\x91\x90a\x1D2V[a\x02\x03a\x05gV[\0[a\x01\xD9a\x06\x92V[a\x01\xD9a\x06\xFDV[a\x02(a\x02#6`\x04a\x1BVV[a\x07hV[`@Qa\x01\xA8\x91\x90a\x1D\xB6V[a\x02\x03a\x07\xABV[a\x02Ea\x08\xCEV[`@Qa\x01\xA8\x91\x90a\x1EIV[a\x02\x03a\nGV[a\x02ba\x0B>V[`@Qa\x01\xA8\x91\x90a\x1E\xC7V[a\x02wa\x0C\tV[`@Qa\x01\xA8\x91\x90a\x1E\xD9V[a\x02wa\r\x0CV[a\x02\x03a\x0E\x0FV[a\x02ba\x0E]V[a\x02\xA4a\x0F(V[`@Q\x90\x15\x15\x81R` \x01a\x01\xA8V[a\x01\xD9a\x0F\xF8V[a\x02\x03a\x10cV[a\x02\x03a\x11\\V[a\x02\x03a\x12UV[`\x1FTa\x02\xA4\x90`\xFF\x16\x81V[a\x02(a\x02\xEF6`\x04a\x1BVV[a\x13\xDAV[``a\x037\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x14\x1DV[\x94\x93PPPPV[``_a\x03M\x85\x85\x85a\x02\xF4V[\x90P_[a\x03[\x85\x85a\x1F\x8AV[\x81\x10\x15a\x03\xA8W\x82\x82\x82\x81Q\x81\x10a\x03uWa\x03ua\x1F\x9DV[` \x02` \x01\x01Q`@Q` \x01a\x03\x8E\x92\x91\x90a\x1F\xE1V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x03QV[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x14W` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xE9W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05^W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x05GW\x83\x82\x90_R` _ \x01\x80Ta\x04\xBC\x90a\x1F\xF5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x04\xE8\x90a\x1F\xF5V[\x80\x15a\x053W\x80`\x1F\x10a\x05\nWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x053V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05\x16W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x04\x9FV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x04AV[PPPP\x90P\x90V[`@\x80Q\x80\x82\x01\x82R`\x1A\x81R\x7FInsufficient confirmations\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x05\xE8\x91\x90`\x04\x01a\x1CnV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05\xFFW__\xFD[PZ\xF1\x15\x80\x15a\x06\x11W=__>=_\xFD[PP`\x1FT`#T`$T`@Qb]\t\xA7`\xE4\x1B\x81Ra\x01\0\x90\x93\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x94Pc\x05\xD0\x9Ap\x93Pa\x06d\x92`!\x92`\"\x92\x90\x91`\t\x90`\x04\x01a!\x1BV[_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x06zW__\xFD[PZ\xFA\x15\x80\x15a\x06\x8CW=__>=_\xFD[PPPPV[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x14W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xE9WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x14W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xE9WPPPPP\x90P\x90V[``a\x037\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x15~V[`@\x80Q\x80\x82\x01\x82R`\x13\x81R\x7FBad inclusion proof\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x08,\x91\x90`\x04\x01a\x1CnV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08CW__\xFD[PZ\xF1\x15\x80\x15a\x08UW=__>=_\xFD[PPPP`\x1F`\x01\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\x05\xD0\x9Ap`!`\"`#T`$T`\x01a\x08\xAD\x91\x90a!`V[_`@Q\x86c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x06d\x95\x94\x93\x92\x91\x90a!\x1BV[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05^W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\t!\x90a\x1F\xF5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\tM\x90a\x1F\xF5V[\x80\x15a\t\x98W\x80`\x1F\x10a\toWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\t\x98V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t{W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\n/W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\t\xDCW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x08\xF1V[`@\x80Q\x80\x82\x01\x82R`\x13\x81R\x7FBad inclusion proof\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\n\xC8\x91\x90`\x04\x01a\x1CnV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\n\xDFW__\xFD[PZ\xF1\x15\x80\x15a\n\xF1W=__>=_\xFD[PP`\x1FT`$T`@Qb]\t\xA7`\xE4\x1B\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x93Pc\x05\xD0\x9Ap\x92Pa\x06d\x91`!\x91`\"\x91_\x90`\x04\x01a!sV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05^W\x83\x82\x90_R` _ \x01\x80Ta\x0B~\x90a\x1F\xF5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\xAA\x90a\x1F\xF5V[\x80\x15a\x0B\xF5W\x80`\x1F\x10a\x0B\xCCWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\xF5V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xD8W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0BaV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05^W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\xF4W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C\xA1W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0C,V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05^W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\xF7W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\xA4W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\r/V[`\x1FT`#T`$T`@Qb]\t\xA7`\xE4\x1B\x81Ra\x01\0\x90\x93\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92c\x05\xD0\x9Ap\x92a\x06d\x92`!\x92`\"\x92\x91\x90_\x90`\x04\x01a!\x1BV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05^W\x83\x82\x90_R` _ \x01\x80Ta\x0E\x9D\x90a\x1F\xF5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0E\xC9\x90a\x1F\xF5V[\x80\x15a\x0F\x14W\x80`\x1F\x10a\x0E\xEBWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F\x14V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0E\xF7W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0E\x80V[`\x08T_\x90`\xFF\x16\x15a\x0F?WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\xCDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xF1\x91\x90a!\xB8V[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x14W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xE9WPPPPP\x90P\x90V[`@\x80Q\x80\x82\x01\x82R`\x13\x81R\x7FBad inclusion proof\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x10\xE4\x91\x90`\x04\x01a\x1CnV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10\xFBW__\xFD[PZ\xF1\x15\x80\x15a\x11\rW=__>=_\xFD[PP`\x1FT`#T`$T`@Qb]\t\xA7`\xE4\x1B\x81Ra\x01\0\x90\x93\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x94Pc\x05\xD0\x9Ap\x93Pa\x06d\x92`!\x92\x91\x90_\x90`\x04\x01a!\xCFV[`@\x80Q\x80\x82\x01\x82R`\x16\x81R\x7FBad merkle array proof\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x11\xDD\x91\x90`\x04\x01a\x1CnV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x11\xF4W__\xFD[PZ\xF1\x15\x80\x15a\x12\x06W=__>=_\xFD[PP`\x1FT`#T`$T`@Qb]\t\xA7`\xE4\x1B\x81Ra\x01\0\x90\x93\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x94Pc\x05\xD0\x9Ap\x93Pa\x06d\x92`!\x92\x91\x90_\x90`\x04\x01a\"\x18V[`\x1FT`@Q\x7F\xF5\x8D\xB0o\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R_`\x04\x82\x01\x81\x90R`$\x82\x01Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90c\xF5\x8D\xB0o\x90`D\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12\xC8W__\xFD[PZ\xF1\x15\x80\x15a\x12\xDAW=__>=_\xFD[PP`@\x80Q\x80\x82\x01\x82R`\x1B\x81R\x7FGCD does not confirm header\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x93Pc\xF2\x8D\xCE\xB3\x92Pa\x13_\x91\x90`\x04\x01a\x1CnV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x13vW__\xFD[PZ\xF1\x15\x80\x15a\x13\x88W=__>=_\xFD[PP`\x1FT`#T`$T`@Qb]\t\xA7`\xE4\x1B\x81Ra\x01\0\x90\x93\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x94Pc\x05\xD0\x9Ap\x93Pa\x06d\x92`!\x92`\"\x92\x90\x91_\x90`\x04\x01a!\x1BV[``a\x037\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x16\xCCV[``a\x14)\x84\x84a\x1F\x8AV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x14AWa\x14Aa\x1A\xD1V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x14tW\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x14_W\x90P[P\x90P\x83[\x83\x81\x10\x15a\x15uWa\x15G\x86a\x14\x8E\x83a\x18\x1AV[\x85`@Q` \x01a\x14\xA1\x93\x92\x91\x90a\"aV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x14\xBD\x90a\x1F\xF5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x14\xE9\x90a\x1F\xF5V[\x80\x15a\x154W\x80`\x1F\x10a\x15\x0BWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x154V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15\x17W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x19K\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x15R\x87\x84a\x1F\x8AV[\x81Q\x81\x10a\x15bWa\x15ba\x1F\x9DV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x14yV[P\x94\x93PPPPV[``a\x15\x8A\x84\x84a\x1F\x8AV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x15\xA2Wa\x15\xA2a\x1A\xD1V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x15\xCBW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x15uWa\x16\x9E\x86a\x15\xE5\x83a\x18\x1AV[\x85`@Q` \x01a\x15\xF8\x93\x92\x91\x90a\"aV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x16\x14\x90a\x1F\xF5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x16@\x90a\x1F\xF5V[\x80\x15a\x16\x8BW\x80`\x1F\x10a\x16bWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x16\x8BV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x16nW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x19\xEA\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x16\xA9\x87\x84a\x1F\x8AV[\x81Q\x81\x10a\x16\xB9Wa\x16\xB9a\x1F\x9DV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x15\xD0V[``a\x16\xD8\x84\x84a\x1F\x8AV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\xF0Wa\x16\xF0a\x1A\xD1V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x17\x19W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x15uWa\x17\xEC\x86a\x173\x83a\x18\x1AV[\x85`@Q` \x01a\x17F\x93\x92\x91\x90a\"aV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x17b\x90a\x1F\xF5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x17\x8E\x90a\x1F\xF5V[\x80\x15a\x17\xD9W\x80`\x1F\x10a\x17\xB0Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x17\xD9V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x17\xBCW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x1A}\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x17\xF7\x87\x84a\x1F\x8AV[\x81Q\x81\x10a\x18\x07Wa\x18\x07a\x1F\x9DV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x17\x1EV[``\x81_\x03a\x18\\WPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x18\x85W\x80a\x18o\x81a\"\xFEV[\x91Pa\x18~\x90P`\n\x83a#bV[\x91Pa\x18_V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\x9FWa\x18\x9Fa\x1A\xD1V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x18\xC9W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x037Wa\x18\xDE`\x01\x83a\x1F\x8AV[\x91Pa\x18\xEB`\n\x86a#uV[a\x18\xF6\x90`0a!`V[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x19\x0BWa\x19\x0Ba\x1F\x9DV[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x19D`\n\x86a#bV[\x94Pa\x18\xCDV[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a\x19\xA0\x90\x86\x90\x86\x90`\x04\x01a#\x88V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x19\xBAW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x19\xE1\x91\x90\x81\x01\x90a#\xB5V[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x1A>\x90\x86\x90\x86\x90`\x04\x01a#\x88V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1AYW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x19\xE1\x91\x90a!\xB8V[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x1A>\x90\x86\x90\x86\x90`\x04\x01a#\x88V[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x1B'Wa\x1B'a\x1A\xD1V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x1BHWa\x1BHa\x1A\xD1V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x1BhW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1B~W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x1B\x8EW__\xFD[\x805a\x1B\xA1a\x1B\x9C\x82a\x1B/V[a\x1A\xFEV[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x1B\xB5W__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1CbW`?\x19\x87\x86\x03\x01\x84Ra\x1CM\x85\x83Qa\x1B\xDDV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1C1V[P\x92\x96\x95PPPPPPV[` \x81R_a\x19\xE1` \x83\x01\x84a\x1B\xDDV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1C\xCDW\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\x1C\x99V[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x1D&W`\x1F\x19\x85\x84\x03\x01\x88Ra\x1D\x10\x83\x83Qa\x1B\xDDV[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x1C\xF4V[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1CbW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1D\xA0`@\x87\x01\x82a\x1C\xD8V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1DXV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1C\xCDW\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1D\xCFV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x1E?W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x1D\xFFV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1CbW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x1E\x95`@\x88\x01\x82a\x1B\xDDV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x1E\xB0\x81\x83a\x1D\xEDV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1EoV[` \x81R_a\x19\xE1` \x83\x01\x84a\x1C\xD8V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1CbW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1FG`@\x87\x01\x82a\x1D\xEDV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1E\xFFV[\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\x19\xE4Wa\x19\xE4a\x1F]V[\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x037a\x1F\xEF\x83\x86a\x1F\xCAV[\x84a\x1F\xCAV[`\x01\x81\x81\x1C\x90\x82\x16\x80a \tW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a @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`\"`\x04R`$_\xFD[P\x91\x90PV[\x80T_\x90`\x01\x81\x81\x1C\x90\x82\x16\x80a ^W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a \x95W\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[\x81\x86R` \x86\x01\x81\x80\x15a \xB0W`\x01\x81\x14a \xE4Wa!\x10V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x85\x16\x82R\x83\x15\x15`\x05\x1B\x82\x01\x95Pa!\x10V[_\x87\x81R` \x90 _[\x85\x81\x10\x15a!\nW\x81T\x84\x82\x01R`\x01\x90\x91\x01\x90` \x01a \xEEV[\x83\x01\x96PP[PPPPP\x92\x91PPV[`\xA0\x81R_a!-`\xA0\x83\x01\x88a FV[\x82\x81\x03` \x84\x01Ra!?\x81\x88a FV[`@\x84\x01\x96\x90\x96RPP``\x81\x01\x92\x90\x92R`\xFF\x16`\x80\x90\x91\x01R\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x19\xE4Wa\x19\xE4a\x1F]V[`\xA0\x81R_a!\x85`\xA0\x83\x01\x87a FV[\x82\x81\x03` \x84\x01Ra!\x97\x81\x87a FV[\x91PP_`@\x83\x01R\x83``\x83\x01R`\xFF\x83\x16`\x80\x83\x01R\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a!\xC8W__\xFD[PQ\x91\x90PV[`\xA0\x81R_a!\xE1`\xA0\x83\x01\x87a FV[\x82\x81\x03` \x84\x01R` \x81R_` \x82\x01R`@\x81\x01\x91PP\x84`@\x83\x01R\x83``\x83\x01R`\xFF\x83\x16`\x80\x83\x01R\x95\x94PPPPPV[`\xA0\x81R_a\"*`\xA0\x83\x01\x87a FV[\x82\x81\x03` \x84\x01R`\x01\x81R_` \x82\x01R`@\x81\x01\x91PP\x84`@\x83\x01R\x83``\x83\x01R`\xFF\x83\x16`\x80\x83\x01R\x95\x94PPPPPV[\x7F.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R_a\"\x92`\x01\x83\x01\x86a\x1F\xCAV[\x7F[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\"\xC2`\x01\x82\x01\x86a\x1F\xCAV[\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\x81Ra\"\xF4`\x02\x82\x01\x85a\x1F\xCAV[\x96\x95PPPPPPV[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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#.Wa#.a\x1F]V[P`\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`\x12`\x04R`$_\xFD[_\x82a#pWa#pa#5V[P\x04\x90V[_\x82a#\x83Wa#\x83a#5V[P\x06\x90V[`@\x81R_a#\x9A`@\x83\x01\x85a\x1B\xDDV[\x82\x81\x03` \x84\x01Ra#\xAC\x81\x85a\x1B\xDDV[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a#\xC5W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a#\xDBW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a#\xEBW__\xFD[\x80Qa#\xF9a\x1B\x9C\x82a\x1B/V[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a$\rW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV\xFE\xA2dipfsX\"\x12 \xB9\xCD\x84\xEFk\xFF\x8D\xA1!u\xE3\x96\x1D\x9B\xC163/wO\xE1\x04\x0EQ\xF8\na\x9B\xA8\xB6{=dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. -```solidity -event log(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getBlockHeights(string,uint256,uint256)` and selector `0xfad06b8f`. -```solidity -function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getBlockHeightsCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getBlockHeights(string,uint256,uint256)`](getBlockHeightsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getBlockHeightsReturn { - #[allow(missing_docs)] - pub elements: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getBlockHeightsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - #[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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getBlockHeightsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getBlockHeightsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getBlockHeights(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [250u8, 208u8, 107u8, 143u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getDigestLes(string,uint256,uint256)` and selector `0x44badbb6`. -```solidity -function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getDigestLesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getDigestLes(string,uint256,uint256)`](getDigestLesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getDigestLesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getDigestLesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getDigestLesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getDigestLesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array< - alloy::sol_types::sol_data::FixedBytes<32>, - >, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getDigestLes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [68u8, 186u8, 219u8, 182u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaderHexes(string,uint256,uint256)` and selector `0x0813852a`. -```solidity -function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaderHexes(string,uint256,uint256)`](getHeaderHexesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeaderHexesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getHeaderHexesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getHeaderHexesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Bytes, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaderHexes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [8u8, 19u8, 133u8, 42u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaders(string,uint256,uint256)` and selector `0x1c0da81f`. -```solidity -function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaders(string,uint256,uint256)`](getHeadersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersReturn { - #[allow(missing_docs)] - pub headers: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersReturn) -> Self { - (value.headers,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { headers: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getHeadersCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Bytes; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaders(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [28u8, 13u8, 168u8, 31u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testGCDDoesntConfirmHeader()` and selector `0xf11d5cbc`. -```solidity -function testGCDDoesntConfirmHeader() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testGCDDoesntConfirmHeaderCall; - ///Container type for the return parameters of the [`testGCDDoesntConfirmHeader()`](testGCDDoesntConfirmHeaderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testGCDDoesntConfirmHeaderReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testGCDDoesntConfirmHeaderCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testGCDDoesntConfirmHeaderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testGCDDoesntConfirmHeaderReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testGCDDoesntConfirmHeaderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testGCDDoesntConfirmHeaderReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testGCDDoesntConfirmHeaderCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testGCDDoesntConfirmHeaderReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testGCDDoesntConfirmHeader()"; - const SELECTOR: [u8; 4] = [241u8, 29u8, 92u8, 188u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testGCDDoesntConfirmHeaderReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testIncorrectProofSupplied()` and selector `0xe89f8419`. -```solidity -function testIncorrectProofSupplied() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIncorrectProofSuppliedCall; - ///Container type for the return parameters of the [`testIncorrectProofSupplied()`](testIncorrectProofSuppliedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIncorrectProofSuppliedReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIncorrectProofSuppliedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIncorrectProofSuppliedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIncorrectProofSuppliedReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIncorrectProofSuppliedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testIncorrectProofSuppliedReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testIncorrectProofSuppliedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testIncorrectProofSuppliedReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testIncorrectProofSupplied()"; - const SELECTOR: [u8; 4] = [232u8, 159u8, 132u8, 25u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testIncorrectProofSuppliedReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testIncorrectTxIdSupplied()` and selector `0x641e144d`. -```solidity -function testIncorrectTxIdSupplied() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIncorrectTxIdSuppliedCall; - ///Container type for the return parameters of the [`testIncorrectTxIdSupplied()`](testIncorrectTxIdSuppliedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIncorrectTxIdSuppliedReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIncorrectTxIdSuppliedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIncorrectTxIdSuppliedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIncorrectTxIdSuppliedReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIncorrectTxIdSuppliedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testIncorrectTxIdSuppliedReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testIncorrectTxIdSuppliedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testIncorrectTxIdSuppliedReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testIncorrectTxIdSupplied()"; - const SELECTOR: [u8; 4] = [100u8, 30u8, 20u8, 77u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testIncorrectTxIdSuppliedReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testIncorrectTxSupplied()` and selector `0x740dba74`. -```solidity -function testIncorrectTxSupplied() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIncorrectTxSuppliedCall; - ///Container type for the return parameters of the [`testIncorrectTxSupplied()`](testIncorrectTxSuppliedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIncorrectTxSuppliedReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIncorrectTxSuppliedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIncorrectTxSuppliedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIncorrectTxSuppliedReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIncorrectTxSuppliedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testIncorrectTxSuppliedReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testIncorrectTxSuppliedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testIncorrectTxSuppliedReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testIncorrectTxSupplied()"; - const SELECTOR: [u8; 4] = [116u8, 13u8, 186u8, 116u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testIncorrectTxSuppliedReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testInsufficientConfirmations()` and selector `0x39425f8f`. -```solidity -function testInsufficientConfirmations() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testInsufficientConfirmationsCall; - ///Container type for the return parameters of the [`testInsufficientConfirmations()`](testInsufficientConfirmationsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testInsufficientConfirmationsReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testInsufficientConfirmationsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testInsufficientConfirmationsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testInsufficientConfirmationsReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testInsufficientConfirmationsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testInsufficientConfirmationsReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testInsufficientConfirmationsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testInsufficientConfirmationsReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testInsufficientConfirmations()"; - const SELECTOR: [u8; 4] = [57u8, 66u8, 95u8, 143u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testInsufficientConfirmationsReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testMalformedProofSupplied()` and selector `0xf0c0832e`. -```solidity -function testMalformedProofSupplied() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testMalformedProofSuppliedCall; - ///Container type for the return parameters of the [`testMalformedProofSupplied()`](testMalformedProofSuppliedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testMalformedProofSuppliedReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testMalformedProofSuppliedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testMalformedProofSuppliedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testMalformedProofSuppliedReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testMalformedProofSuppliedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testMalformedProofSuppliedReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testMalformedProofSuppliedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testMalformedProofSuppliedReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testMalformedProofSupplied()"; - const SELECTOR: [u8; 4] = [240u8, 192u8, 131u8, 46u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testMalformedProofSuppliedReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testSuccessfullyVerify()` and selector `0xb52b2058`. -```solidity -function testSuccessfullyVerify() external view; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testSuccessfullyVerifyCall; - ///Container type for the return parameters of the [`testSuccessfullyVerify()`](testSuccessfullyVerifyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testSuccessfullyVerifyReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testSuccessfullyVerifyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testSuccessfullyVerifyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testSuccessfullyVerifyReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testSuccessfullyVerifyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testSuccessfullyVerifyReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testSuccessfullyVerifyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testSuccessfullyVerifyReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testSuccessfullyVerify()"; - const SELECTOR: [u8; 4] = [181u8, 43u8, 32u8, 88u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testSuccessfullyVerifyReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`FullRelayWithVerifyDirectTest`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum FullRelayWithVerifyDirectTestCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - getBlockHeights(getBlockHeightsCall), - #[allow(missing_docs)] - getDigestLes(getDigestLesCall), - #[allow(missing_docs)] - getHeaderHexes(getHeaderHexesCall), - #[allow(missing_docs)] - getHeaders(getHeadersCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - testGCDDoesntConfirmHeader(testGCDDoesntConfirmHeaderCall), - #[allow(missing_docs)] - testIncorrectProofSupplied(testIncorrectProofSuppliedCall), - #[allow(missing_docs)] - testIncorrectTxIdSupplied(testIncorrectTxIdSuppliedCall), - #[allow(missing_docs)] - testIncorrectTxSupplied(testIncorrectTxSuppliedCall), - #[allow(missing_docs)] - testInsufficientConfirmations(testInsufficientConfirmationsCall), - #[allow(missing_docs)] - testMalformedProofSupplied(testMalformedProofSuppliedCall), - #[allow(missing_docs)] - testSuccessfullyVerify(testSuccessfullyVerifyCall), - } - #[automatically_derived] - impl FullRelayWithVerifyDirectTestCalls { - /// 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, 19u8, 133u8, 42u8], - [28u8, 13u8, 168u8, 31u8], - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [57u8, 66u8, 95u8, 143u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [68u8, 186u8, 219u8, 182u8], - [100u8, 30u8, 20u8, 77u8], - [102u8, 217u8, 169u8, 160u8], - [116u8, 13u8, 186u8, 116u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 43u8, 32u8, 88u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [226u8, 12u8, 159u8, 113u8], - [232u8, 159u8, 132u8, 25u8], - [240u8, 192u8, 131u8, 46u8], - [241u8, 29u8, 92u8, 188u8], - [250u8, 118u8, 38u8, 212u8], - [250u8, 208u8, 107u8, 143u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for FullRelayWithVerifyDirectTestCalls { - const NAME: &'static str = "FullRelayWithVerifyDirectTestCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 23usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::getBlockHeights(_) => { - ::SELECTOR - } - Self::getDigestLes(_) => { - ::SELECTOR - } - Self::getHeaderHexes(_) => { - ::SELECTOR - } - Self::getHeaders(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::testGCDDoesntConfirmHeader(_) => { - ::SELECTOR - } - Self::testIncorrectProofSupplied(_) => { - ::SELECTOR - } - Self::testIncorrectTxIdSupplied(_) => { - ::SELECTOR - } - Self::testIncorrectTxSupplied(_) => { - ::SELECTOR - } - Self::testInsufficientConfirmations(_) => { - ::SELECTOR - } - Self::testMalformedProofSupplied(_) => { - ::SELECTOR - } - Self::testSuccessfullyVerify(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::getHeaderHexes) - } - getHeaderHexes - }, - { - fn getHeaders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::getHeaders) - } - getHeaders - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn testInsufficientConfirmations( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyDirectTestCalls::testInsufficientConfirmations, - ) - } - testInsufficientConfirmations - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::targetContracts) - } - targetContracts - }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::getDigestLes) - } - getDigestLes - }, - { - fn testIncorrectTxIdSupplied( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyDirectTestCalls::testIncorrectTxIdSupplied, - ) - } - testIncorrectTxIdSupplied - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyDirectTestCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn testIncorrectTxSupplied( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyDirectTestCalls::testIncorrectTxSupplied, - ) - } - testIncorrectTxSupplied - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn testSuccessfullyVerify( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyDirectTestCalls::testSuccessfullyVerify, - ) - } - testSuccessfullyVerify - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(FullRelayWithVerifyDirectTestCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::excludeContracts) - } - excludeContracts - }, - { - fn testIncorrectProofSupplied( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyDirectTestCalls::testIncorrectProofSupplied, - ) - } - testIncorrectProofSupplied - }, - { - fn testMalformedProofSupplied( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyDirectTestCalls::testMalformedProofSupplied, - ) - } - testMalformedProofSupplied - }, - { - fn testGCDDoesntConfirmHeader( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyDirectTestCalls::testGCDDoesntConfirmHeader, - ) - } - testGCDDoesntConfirmHeader - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(FullRelayWithVerifyDirectTestCalls::IS_TEST) - } - IS_TEST - }, - { - fn getBlockHeights( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::getBlockHeights) - } - getBlockHeights - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::getHeaderHexes) - } - getHeaderHexes - }, - { - fn getHeaders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::getHeaders) - } - getHeaders - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn testInsufficientConfirmations( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyDirectTestCalls::testInsufficientConfirmations, - ) - } - testInsufficientConfirmations - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::targetContracts) - } - targetContracts - }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::getDigestLes) - } - getDigestLes - }, - { - fn testIncorrectTxIdSupplied( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyDirectTestCalls::testIncorrectTxIdSupplied, - ) - } - testIncorrectTxIdSupplied - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyDirectTestCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn testIncorrectTxSupplied( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyDirectTestCalls::testIncorrectTxSupplied, - ) - } - testIncorrectTxSupplied - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn testSuccessfullyVerify( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyDirectTestCalls::testSuccessfullyVerify, - ) - } - testSuccessfullyVerify - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::excludeContracts) - } - excludeContracts - }, - { - fn testIncorrectProofSupplied( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyDirectTestCalls::testIncorrectProofSupplied, - ) - } - testIncorrectProofSupplied - }, - { - fn testMalformedProofSupplied( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyDirectTestCalls::testMalformedProofSupplied, - ) - } - testMalformedProofSupplied - }, - { - fn testGCDDoesntConfirmHeader( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyDirectTestCalls::testGCDDoesntConfirmHeader, - ) - } - testGCDDoesntConfirmHeader - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::IS_TEST) - } - IS_TEST - }, - { - fn getBlockHeights( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayWithVerifyDirectTestCalls::getBlockHeights) - } - getBlockHeights - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::getBlockHeights(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getDigestLes(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getHeaders(inner) => { - ::abi_encoded_size(inner) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testGCDDoesntConfirmHeader(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testIncorrectProofSupplied(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testIncorrectTxIdSupplied(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testIncorrectTxSupplied(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testInsufficientConfirmations(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testMalformedProofSupplied(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testSuccessfullyVerify(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::getBlockHeights(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getDigestLes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testGCDDoesntConfirmHeader(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testIncorrectProofSupplied(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testIncorrectTxIdSupplied(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testIncorrectTxSupplied(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testInsufficientConfirmations(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testMalformedProofSupplied(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testSuccessfullyVerify(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`FullRelayWithVerifyDirectTest`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum FullRelayWithVerifyDirectTestEvents { - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl FullRelayWithVerifyDirectTestEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for FullRelayWithVerifyDirectTestEvents { - const NAME: &'static str = "FullRelayWithVerifyDirectTestEvents"; - const COUNT: usize = 22usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 FullRelayWithVerifyDirectTestEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`FullRelayWithVerifyDirectTest`](self) contract instance. - -See the [wrapper's documentation](`FullRelayWithVerifyDirectTestInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> FullRelayWithVerifyDirectTestInstance { - FullRelayWithVerifyDirectTestInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - FullRelayWithVerifyDirectTestInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - FullRelayWithVerifyDirectTestInstance::::deploy_builder(provider) - } - /**A [`FullRelayWithVerifyDirectTest`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`FullRelayWithVerifyDirectTest`](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 FullRelayWithVerifyDirectTestInstance< - P, - N = alloy_contract::private::Ethereum, - > { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for FullRelayWithVerifyDirectTestInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("FullRelayWithVerifyDirectTestInstance") - .field(&self.address) - .finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayWithVerifyDirectTestInstance { - /**Creates a new wrapper around an on-chain [`FullRelayWithVerifyDirectTest`](self) contract instance. - -See the [wrapper's documentation](`FullRelayWithVerifyDirectTestInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 FullRelayWithVerifyDirectTestInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider( - self, - ) -> FullRelayWithVerifyDirectTestInstance { - FullRelayWithVerifyDirectTestInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayWithVerifyDirectTestInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`getBlockHeights`] function. - pub fn getBlockHeights( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getBlockHeightsCall, N> { - self.call_builder( - &getBlockHeightsCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getDigestLes`] function. - pub fn getDigestLes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getDigestLesCall, N> { - self.call_builder( - &getDigestLesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaderHexes`] function. - pub fn getHeaderHexes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeaderHexesCall, N> { - self.call_builder( - &getHeaderHexesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaders`] function. - pub fn getHeaders( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeadersCall, N> { - self.call_builder( - &getHeadersCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`testGCDDoesntConfirmHeader`] function. - pub fn testGCDDoesntConfirmHeader( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testGCDDoesntConfirmHeaderCall, N> { - self.call_builder(&testGCDDoesntConfirmHeaderCall) - } - ///Creates a new call builder for the [`testIncorrectProofSupplied`] function. - pub fn testIncorrectProofSupplied( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testIncorrectProofSuppliedCall, N> { - self.call_builder(&testIncorrectProofSuppliedCall) - } - ///Creates a new call builder for the [`testIncorrectTxIdSupplied`] function. - pub fn testIncorrectTxIdSupplied( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testIncorrectTxIdSuppliedCall, N> { - self.call_builder(&testIncorrectTxIdSuppliedCall) - } - ///Creates a new call builder for the [`testIncorrectTxSupplied`] function. - pub fn testIncorrectTxSupplied( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testIncorrectTxSuppliedCall, N> { - self.call_builder(&testIncorrectTxSuppliedCall) - } - ///Creates a new call builder for the [`testInsufficientConfirmations`] function. - pub fn testInsufficientConfirmations( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testInsufficientConfirmationsCall, N> { - self.call_builder(&testInsufficientConfirmationsCall) - } - ///Creates a new call builder for the [`testMalformedProofSupplied`] function. - pub fn testMalformedProofSupplied( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testMalformedProofSuppliedCall, N> { - self.call_builder(&testMalformedProofSuppliedCall) - } - ///Creates a new call builder for the [`testSuccessfullyVerify`] function. - pub fn testSuccessfullyVerify( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testSuccessfullyVerifyCall, N> { - self.call_builder(&testSuccessfullyVerifyCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayWithVerifyDirectTestInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/fullrelaywithverifythroughbitcointxtest.rs b/crates/bindings/src/fullrelaywithverifythroughbitcointxtest.rs deleted file mode 100644 index a218b60e2..000000000 --- a/crates/bindings/src/fullrelaywithverifythroughbitcointxtest.rs +++ /dev/null @@ -1,10208 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface FullRelayWithVerifyThroughBitcoinTxTest { - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); - function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); - function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); - function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function testGCDDoesntConfirmHeader() external; - function testIncorrectInputVectorSupplied() external; - function testIncorrectLocktimeSupplied() external; - function testIncorrectOutputVectorSupplied() external; - function testIncorrectProofSupplied() external; - function testInsufficientConfirmations() external; - function testInvalidHeaderSupplied() external; - function testInvalidMerkleProofSupplied() external; - function testSuccessfullyVerify() external view; -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getBlockHeights", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getDigestLes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes32[]", - "internalType": "bytes32[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaderHexes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes[]", - "internalType": "bytes[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaders", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "headers", - "type": "bytes", - "internalType": "bytes" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testGCDDoesntConfirmHeader", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testIncorrectInputVectorSupplied", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testIncorrectLocktimeSupplied", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testIncorrectOutputVectorSupplied", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testIncorrectProofSupplied", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testInsufficientConfirmations", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testInvalidHeaderSupplied", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testInvalidMerkleProofSupplied", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testSuccessfullyVerify", - "inputs": [], - "outputs": [], - "stateMutability": "view" - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 FullRelayWithVerifyThroughBitcoinTxTest { - use super::*; - use alloy::sol_types as 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"`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90Ua\x01\0`@R`P`\x80\x81\x81R\x90au\xB1`\xA09`!\x90a\0=\x90\x82a\t\x81V[P`@Q\x80a\x01`\x01`@R\x80a\x01@\x81R` \x01av\x8Ca\x01@\x919`\"\x90a\0g\x90\x82a\t\x81V[P_Q` avl_9_Q\x90_R`#Ua\x01\x19`$U`@Qa\0\x8B\x90a\x08\xCFV[`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\0\xA4W=__>=_\xFD[P`%_a\x01\0\n\x81T\x81`\x01`\x01`\xA0\x1B\x03\x02\x19\x16\x90\x83`\x01`\x01`\xA0\x1B\x03\x16\x02\x17\x90UP`\x01`&U_Q` avl_9_Q\x90_R`'U`@Q\x80`\x80\x01`@R\x80`\x01`\xF8\x1B`\x01`\x01`\xE0\x1B\x03\x19\x16\x81R` \x01`@Q\x80``\x01`@R\x80`*\x81R` \x01aw\xCC`*\x919\x81R` \x01`@Q\x80`\x80\x01`@R\x80`K\x81R` \x01av!`K\x919\x81R_` \x91\x82\x01R\x81Q`(\x80Tc\xFF\xFF\xFF\xFF\x19\x16`\xE0\x92\x90\x92\x1C\x91\x90\x91\x17\x81U\x90\x82\x01Q`)\x90a\x01i\x90\x82a\t\x81V[P`@\x82\x01Q`\x02\x82\x01\x90a\x01~\x90\x82a\t\x81V[P``\x82\x01Q\x81`\x03\x01_a\x01\0\n\x81T\x81c\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83`\xE0\x1C\x02\x17\x90UPPP`@Q\x80`\xA0\x01`@R\x80`\"\x80Ta\x01\xBC\x90a\x08\xFDV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x01\xE8\x90a\x08\xFDV[\x80\x15a\x023W\x80`\x1F\x10a\x02\nWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x023V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02\x16W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01a\x01\x19\x81R` \x01`!\x80Ta\x02R\x90a\x08\xFDV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02~\x90a\x08\xFDV[\x80\x15a\x02\xC9W\x80`\x1F\x10a\x02\xA0Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02\xC9V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02\xACW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x7Fw\xB9\x8A^fC\x97;\xBAI\xDD\xA1\x8Au\x14\x03\x06\xD2\xD8iKf\xF2\xDC\xB3V\x1A\xD5\xAF\xF0\xB0\xC7\x81R` \x01`@Q\x80a\x01`\x01`@R\x80a\x01@\x81R` \x01aw\xF6a\x01@\x919\x90R\x80Q`,\x90\x81\x90a\x03(\x90\x82a\t\x81V[P` \x82\x01Q`\x01\x82\x01U`@\x82\x01Q`\x02\x82\x01\x90a\x03G\x90\x82a\t\x81V[P``\x82\x01Q`\x03\x82\x01U`\x80\x82\x01Q`\x04\x82\x01\x90a\x03f\x90\x82a\t\x81V[PPP4\x80\x15a\x03tW__\xFD[P`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k42\xB0\xB22\xB99\x9759\xB7\xB7`\xA1\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k\x05\xCC\xEC\xAD\xCC\xAEm.e\xCD\x0C\xAF`\xA3\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x0F\x81R` \x01n\x0B\x99\xD9[\x99\\\xDA\\\xCB\x9A\x19ZY\xDA\x1D`\x8A\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01q.genesis.digest_le`p\x1B\x81RP__Q` av\x01_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x16c\xD90\xA0\xE6`@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=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x04\x82\x91\x90\x81\x01\x90a\n\xB0V[\x90P_\x81\x86`@Q` \x01a\x04\x98\x92\x91\x90a\x0B\x13V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Rc`\xF9\xBB\x11`\xE0\x1B\x82R\x91P_Q` av\x01_9_Q\x90_R\x90c`\xF9\xBB\x11\x90a\x04\xD8\x90\x84\x90`\x04\x01a\x0B\x85V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04\xF2W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x05\x19\x91\x90\x81\x01\x90a\n\xB0V[` \x90a\x05&\x90\x82a\t\x81V[Pa\x05\xBD\x85` \x80Ta\x058\x90a\x08\xFDV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05d\x90a\x08\xFDV[\x80\x15a\x05\xAFW\x80`\x1F\x10a\x05\x86Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05\xAFV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05\x92W\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x07\xAB\x91PPV[a\x06S\x85` \x80Ta\x05\xCE\x90a\x08\xFDV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05\xFA\x90a\x08\xFDV[\x80\x15a\x06EW\x80`\x1F\x10a\x06\x1CWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x06EV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x06(W\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x08(\x91PPV[a\x06\xE9\x85` \x80Ta\x06d\x90a\x08\xFDV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06\x90\x90a\x08\xFDV[\x80\x15a\x06\xDBW\x80`\x1F\x10a\x06\xB2Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x06\xDBV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x06\xBEW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x08\x9B\x91PPV[`@Qa\x06\xF5\x90a\x08\xDCV[a\x07\x01\x93\x92\x91\x90a\x0B\x97V[`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x07\x1AW=__>=_\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16a\x01\0`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x81\x02\x91\x90\x91\x17\x91\x82\x90U`@Qc\xF5\x8D\xB0o`\xE0\x1B\x81R`\x01`\x04\x82\x01\x81\x90R`$\x82\x01R\x91\x04\x90\x91\x16\x96Pc\xF5\x8D\xB0o\x95P`D\x01\x93Pa\x07y\x92PPPV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07\x90W__\xFD[PZ\xF1\x15\x80\x15a\x07\xA2W=__>=_\xFD[PPPPa\x0B\xF6V[`@Qc\x1F\xB2C}`\xE3\x1B\x81R``\x90_Q` av\x01_9_Q\x90_R\x90c\xFD\x92\x1B\xE8\x90a\x07\xE0\x90\x86\x90\x86\x90`\x04\x01a\x0B\xBBV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07\xFAW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x08!\x91\x90\x81\x01\x90a\n\xB0V[\x93\x92PPPV[`@QcV\xEE\xF1[`\xE1\x1B\x81R_\x90_Q` av\x01_9_Q\x90_R\x90c\xAD\xDD\xE2\xB6\x90a\x08\\\x90\x86\x90\x86\x90`\x04\x01a\x0B\xBBV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08wW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08!\x91\x90a\x0B\xDFV[`@Qc\x17w\xE5\x9D`\xE0\x1B\x81R_\x90_Q` av\x01_9_Q\x90_R\x90c\x17w\xE5\x9D\x90a\x08\\\x90\x86\x90\x86\x90`\x04\x01a\x0B\xBBV[a\x0F\xF9\x80a<}\x839\x01\x90V[a);\x80aLv\x839\x01\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`\x01\x81\x81\x1C\x90\x82\x16\x80a\t\x11W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\t/WcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\t|W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\tZWP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\tyW_\x81U`\x01\x01a\tfV[PP[PPPV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\t\x9AWa\t\x9Aa\x08\xE9V[a\t\xAE\x81a\t\xA8\x84Ta\x08\xFDV[\x84a\t5V[` `\x1F\x82\x11`\x01\x81\x14a\t\xE0W_\x83\x15a\t\xC9WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\tyV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\n\x0FW\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\t\xEFV[P\x84\x82\x10\x15a\n,W\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[_\x80`\x01`\x01`@\x1B\x03\x84\x11\x15a\nTWa\nTa\x08\xE9V[P`@Q`\x1F\x19`\x1F\x85\x01\x81\x16`?\x01\x16\x81\x01\x81\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17\x15a\n\x82Wa\n\x82a\x08\xE9V[`@R\x83\x81R\x90P\x80\x82\x84\x01\x85\x10\x15a\n\x99W__\xFD[\x83\x83` \x83\x01^_` \x85\x83\x01\x01RP\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\n\xC0W__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\n\xD5W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\n\xE5W__\xFD[a\n\xF4\x84\x82Q` \x84\x01a\n;V[\x94\x93PPPPV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x0B\x1E\x82\x85a\n\xFCV[\x7F/test/fullRelay/testData/\0\0\0\0\0\0\0\x81Ra\x0BN`\x19\x82\x01\x85a\n\xFCV[\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R_a\x08!` \x83\x01\x84a\x0BWV[``\x81R_a\x0B\xA9``\x83\x01\x86a\x0BWV[` \x83\x01\x94\x90\x94RP`@\x01R\x91\x90PV[`@\x81R_a\x0B\xCD`@\x83\x01\x85a\x0BWV[\x82\x81\x03` \x84\x01Ra\x0BN\x81\x85a\x0BWV[_` \x82\x84\x03\x12\x15a\x0B\xEFW__\xFD[PQ\x91\x90PV[a0z\x80a\x0C\x03_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x9AW_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\xE8W\x80c\xE2\x0C\x9Fq\x11a\0\x93W\x80c\xEF>h\x12\x11a\0nW\x80c\xEF>h\x12\x14a\x02\xE2W\x80c\xF1\x1D\\\xBC\x14a\x02\xEAW\x80c\xFAv&\xD4\x14a\x02\xF2W\x80c\xFA\xD0k\x8F\x14a\x02\xFFW__\xFD[\x80c\xE2\x0C\x9Fq\x14a\x02\xD2W\x80c\xE8\x9F\x84\x19\x14a\x02\xDAW\x80c\xEDZ\x9CI\x14a\x02\xDAW__\xFD[\x80c\xB5P\x8A\xA9\x11a\0\xC3W\x80c\xB5P\x8A\xA9\x14a\x02\xAAW\x80c\xBAAO\xA6\x14a\x02\xB2W\x80c\xC8\x99\xD2A\x14a\x02\xCAW__\xFD[\x80c\x91j\x17\xC6\x14a\x02\x85W\x80c\xB0FO\xDC\x14a\x02\x9AW\x80c\xB5+ X\x14a\x02\xA2W__\xFD[\x80c?r\x86\xF4\x11a\x01HW\x80cc*\xD54\x11a\x01#W\x80cc*\xD54\x14a\x02SW\x80cf\xD9\xA9\xA0\x14a\x02[W\x80c\x85\"l\x81\x14a\x02pW__\xFD[\x80c?r\x86\xF4\x14a\x02#W\x80cD\xBA\xDB\xB6\x14a\x02+W\x80c]\xF0\xD0v\x14a\x02KW__\xFD[\x80c*\xDE8\x80\x11a\x01xW\x80c*\xDE8\x80\x14a\x01\xFCW\x80c9B_\x8F\x14a\x02\x11W\x80c>^<#\x14a\x02\x1BW__\xFD[\x80c\x08\x13\x85*\x14a\x01\x9EW\x80c\x1C\r\xA8\x1F\x14a\x01\xC7W\x80c\x1E\xD7\x83\x1C\x14a\x01\xE7W[__\xFD[a\x01\xB1a\x01\xAC6`\x04a%DV[a\x03\x12V[`@Qa\x01\xBE\x91\x90a%\xF9V[`@Q\x80\x91\x03\x90\xF3[a\x01\xDAa\x01\xD56`\x04a%DV[a\x03]V[`@Qa\x01\xBE\x91\x90a&\\V[a\x01\xEFa\x03\xCFV[`@Qa\x01\xBE\x91\x90a&nV[a\x02\x04a\x04a\x0296`\x04a%DV[a\x07\xB7V[`@Qa\x01\xBE\x91\x90a'\xA4V[a\x02\x19a\x07\xFAV[a\x02\x19a\n\xB5V[a\x02ca\r\xBFV[`@Qa\x01\xBE\x91\x90a(7V[a\x02xa\x0F8V[`@Qa\x01\xBE\x91\x90a(\xB5V[a\x02\x8Da\x10\x03V[`@Qa\x01\xBE\x91\x90a(\xC7V[a\x02\x8Da\x11\x06V[a\x02\x19a\x12\tV[a\x02xa\x12\xC6V[a\x02\xBAa\x13\x91V[`@Q\x90\x15\x15\x81R` \x01a\x01\xBEV[a\x02\x19a\x14aV[a\x01\xEFa\x16eV[a\x02\x19a\x16\xD0V[a\x02\x19a\x19@V[a\x02\x19a\x1BeV[`\x1FTa\x02\xBA\x90`\xFF\x16\x81V[a\x02>a\x03\r6`\x04a%DV[a\x1DEV[``a\x03U\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1D\x88V[\x94\x93PPPPV[``_a\x03k\x85\x85\x85a\x03\x12V[\x90P_[a\x03y\x85\x85a)xV[\x81\x10\x15a\x03\xC6W\x82\x82\x82\x81Q\x81\x10a\x03\x93Wa\x03\x93a)\x8BV[` \x02` \x01\x01Q`@Q` \x01a\x03\xAC\x92\x91\x90a)\xCFV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x03oV[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x042W` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04\x07W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05|W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x05eW\x83\x82\x90_R` _ \x01\x80Ta\x04\xDA\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05\x06\x90a)\xE3V[\x80\x15a\x05QW\x80`\x1F\x10a\x05(Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05QV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x054W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x04\xBDV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x04_V[PPPP\x90P\x90V[`@\x80Q\x80\x82\x01\x82R`\x1A\x81R\x7FInsufficient confirmations\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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`\t\x91sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x06\x08\x91`\x04\x01a&\\V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x06\x1FW__\xFD[PZ\xF1\x15\x80\x15a\x061W=__>=_\xFD[PP`%T`\x1FT`@Q\x7F-y\xDBF\0\0\0\0\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\x94Pc-y\xDBF\x93Pa\x06\x9E\x92a\x01\0\x90\x92\x04\x90\x91\x16\x90\x85\x90`(\x90`,\x90`\x04\x01a+\xECV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xB9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xDD\x91\x90a,=V[PPV[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x042W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04\x07WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x042W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04\x07WPPPPP\x90P\x90V[``a\x03U\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1E\xE9V[`@\x80Q`\x80\x81\x01\x90\x91R`(\x80T`\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\x82R`)\x80T_\x93\x92\x91` \x84\x01\x91a\x08F\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x08r\x90a)\xE3V[\x80\x15a\x08\xBDW\x80`\x1F\x10a\x08\x94Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x08\xBDV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x08\xA0W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x02\x82\x01\x80Ta\x08\xD6\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\t\x02\x90a)\xE3V[\x80\x15a\tMW\x80`\x1F\x10a\t$Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\tMV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t0W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x83RPP`\x03\x91\x90\x91\x01T`\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` \x91\x82\x01R`@\x80Q\x80\x82\x01\x82R`\x01\x81R_\x81\x84\x01R\x83\x82\x01R\x80Q\x80\x82\x01\x82R`\x1E\x81R\x7FInvalid output vector provided\0\0\x92\x81\x01\x92\x90\x92RQ\x7F\xF2\x8D\xCE\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\x91\x92Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\n\x1F\x91`\x04\x01a&\\V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\n6W__\xFD[PZ\xF1\x15\x80\x15a\nHW=__>=_\xFD[PP`%T`\x1FT`&T`@Q\x7F-y\xDBF\0\0\0\0\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\x93\x84\x16\x95Pc-y\xDBF\x94Pa\x06\x9E\x93a\x01\0\x90\x93\x04\x90\x92\x16\x91\x86\x90`,\x90`\x04\x01a,TV[_`,`@Q\x80`\xA0\x01`@R\x90\x81_\x82\x01\x80Ta\n\xD2\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n\xFE\x90a)\xE3V[\x80\x15a\x0BIW\x80`\x1F\x10a\x0B Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0BIV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B,W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01T\x81R` \x01`\x02\x82\x01\x80Ta\x0Bl\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\x98\x90a)\xE3V[\x80\x15a\x0B\xE3W\x80`\x1F\x10a\x0B\xBAWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\xE3V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xC6W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x03\x82\x01T\x81R` \x01`\x04\x82\x01\x80Ta\x0C\x06\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C2\x90a)\xE3V[\x80\x15a\x0C}W\x80`\x1F\x10a\x0CTWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C}V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0C`W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81RPP\x90P`@Q\x80`\x80\x01`@R\x80`O\x81R` \x01a/\xF6`O\x919`@\x80\x83\x01\x91\x90\x91R\x80Q\x80\x82\x01\x82R`\x10\x81R\x7FBad header block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\r)\x91\x90`\x04\x01a&\\V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\r@W__\xFD[PZ\xF1\x15\x80\x15a\rRW=__>=_\xFD[PP`%T`\x1FT`&T`@Q\x7F-y\xDBF\0\0\0\0\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\x93\x84\x16\x95Pc-y\xDBF\x94Pa\x06\x9E\x93a\x01\0\x90\x93\x04\x90\x92\x16\x91`(\x90\x87\x90`\x04\x01a-:V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05|W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x0E\x12\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0E>\x90a)\xE3V[\x80\x15a\x0E\x89W\x80`\x1F\x10a\x0E`Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0E\x89V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0ElW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x0F W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0E\xCDW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\r\xE2V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05|W\x83\x82\x90_R` _ \x01\x80Ta\x0Fx\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F\xA4\x90a)\xE3V[\x80\x15a\x0F\xEFW\x80`\x1F\x10a\x0F\xC6Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F\xEFV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\xD2W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0F[V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05|W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x10\xEEW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x10\x9BW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x10&V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05|W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x11\xF1W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x11\x9EW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x11)V[`%T`\x1FT`&T`@Q\x7F-y\xDBF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R_\x93s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16\x93c-y\xDBF\x93a\x12v\x93a\x01\0\x90\x92\x04\x90\x92\x16\x91\x90`(\x90`,\x90`\x04\x01a+\xECV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x12\x91W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xB5\x91\x90a,=V[\x90Pa\x12\xC3\x81`'Ta 7V[PV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05|W\x83\x82\x90_R` _ \x01\x80Ta\x13\x06\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x132\x90a)\xE3V[\x80\x15a\x13}W\x80`\x1F\x10a\x13TWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x13}V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x13`W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x12\xE9V[`\x08T_\x90`\xFF\x16\x15a\x13\xA8WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x146W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x14Z\x91\x90a,=V[\x14\x15\x90P\x90V[`@\x80Q`\x80\x81\x01\x90\x91R`(\x80T`\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\x82R`)\x80T_\x93\x92\x91` \x84\x01\x91a\x14\xAD\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x14\xD9\x90a)\xE3V[\x80\x15a\x15$W\x80`\x1F\x10a\x14\xFBWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x15$V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15\x07W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x02\x82\x01\x80Ta\x15=\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x15i\x90a)\xE3V[\x80\x15a\x15\xB4W\x80`\x1F\x10a\x15\x8BWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x15\xB4V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15\x97W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x83RPP`\x03\x91\x90\x91\x01T`\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` \x91\x82\x01R|\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``\x83\x81\x01\x91\x90\x91R`@\x80Q\x91\x82\x01\x90R`<\x80\x82R\x92\x93Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x92c\xF2\x8D\xCE\xB3\x92a/\xBA\x90\x83\x019`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\n\x1F\x91\x90a&\\V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x042W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04\x07WPPPPP\x90P\x90V[_`,`@Q\x80`\xA0\x01`@R\x90\x81_\x82\x01\x80Ta\x16\xED\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x17\x19\x90a)\xE3V[\x80\x15a\x17dW\x80`\x1F\x10a\x17;Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x17dV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x17GW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01T\x81R` \x01`\x02\x82\x01\x80Ta\x17\x87\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x17\xB3\x90a)\xE3V[\x80\x15a\x17\xFEW\x80`\x1F\x10a\x17\xD5Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x17\xFEV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x17\xE1W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x03\x82\x01T\x81R` \x01`\x04\x82\x01\x80Ta\x18!\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x18M\x90a)\xE3V[\x80\x15a\x18\x98W\x80`\x1F\x10a\x18oWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x18\x98V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x18{W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPP`@\x80Q\x80\x82\x01\x82R`\x01\x81R_` \x80\x83\x01\x91\x90\x91R\x90\x84R\x81Q\x80\x83\x01\x83R`\x16\x81R\x7FBad merkle array proof\0\0\0\0\0\0\0\0\0\0\x91\x81\x01\x91\x90\x91R\x90Q\x7F\xF2\x8D\xCE\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\x92\x93Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x92c\xF2\x8D\xCE\xB3\x92Pa\r)\x91\x90`\x04\x01a&\\V[`@\x80Q`\x80\x81\x01\x90\x91R`(\x80T`\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\x82R`)\x80T_\x93\x92\x91` \x84\x01\x91a\x19\x8C\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x19\xB8\x90a)\xE3V[\x80\x15a\x1A\x03W\x80`\x1F\x10a\x19\xDAWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x1A\x03V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x19\xE6W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x02\x82\x01\x80Ta\x1A\x1C\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x1AH\x90a)\xE3V[\x80\x15a\x1A\x93W\x80`\x1F\x10a\x1AjWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x1A\x93V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x1AvW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x83RPP`\x03\x91\x90\x91\x01T`\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` \x91\x82\x01R`@\x80Q\x80\x82\x01\x82R`\x01\x81R_\x81\x84\x01R\x83\x83\x01R\x80Q\x80\x82\x01\x82R`\x1D\x81R\x7FInvalid input vector provided\0\0\0\x92\x81\x01\x92\x90\x92RQ\x7F\xF2\x8D\xCE\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\x91\x92Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\n\x1F\x91`\x04\x01a&\\V[`\x1FT`@Q\x7F\xF5\x8D\xB0o\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R_`\x04\x82\x01\x81\x90R`$\x82\x01Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90c\xF5\x8D\xB0o\x90`D\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1B\xD8W__\xFD[PZ\xF1\x15\x80\x15a\x1B\xEAW=__>=_\xFD[PP`@\x80Q\x80\x82\x01\x82R`\x1B\x81R\x7FGCD does not confirm header\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x93Pc\xF2\x8D\xCE\xB3\x92Pa\x1Co\x91\x90`\x04\x01a&\\V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1C\x86W__\xFD[PZ\xF1\x15\x80\x15a\x1C\x98W=__>=_\xFD[PP`%T`\x1FT`&T`@Q\x7F-y\xDBF\0\0\0\0\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\x93\x84\x16\x95Pc-y\xDBF\x94Pa\x1D\x06\x93a\x01\0\x90\x93\x04\x90\x92\x16\x91`(\x90`,\x90`\x04\x01a+\xECV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1D!W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xC3\x91\x90a,=V[``a\x03U\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa \xBAV[``a\x1D\x94\x84\x84a)xV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xACWa\x1D\xACa$\xBFV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x1D\xDFW\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x1D\xCAW\x90P[P\x90P\x83[\x83\x81\x10\x15a\x1E\xE0Wa\x1E\xB2\x86a\x1D\xF9\x83a\"\x08V[\x85`@Q` \x01a\x1E\x0C\x93\x92\x91\x90a-\xDDV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x1E(\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x1ET\x90a)\xE3V[\x80\x15a\x1E\x9FW\x80`\x1F\x10a\x1EvWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x1E\x9FV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x1E\x82W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa#9\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x1E\xBD\x87\x84a)xV[\x81Q\x81\x10a\x1E\xCDWa\x1E\xCDa)\x8BV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x1D\xE4V[P\x94\x93PPPPV[``a\x1E\xF5\x84\x84a)xV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\rWa\x1F\ra$\xBFV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x1F6W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x1E\xE0Wa \t\x86a\x1FP\x83a\"\x08V[\x85`@Q` \x01a\x1Fc\x93\x92\x91\x90a-\xDDV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x1F\x7F\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x1F\xAB\x90a)\xE3V[\x80\x15a\x1F\xF6W\x80`\x1F\x10a\x1F\xCDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x1F\xF6V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x1F\xD9W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa#\xD8\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a \x14\x87\x84a)xV[\x81Q\x81\x10a $Wa $a)\x8BV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x1F;V[`@Q\x7F|\x84\xC6\x9B\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c|\x84\xC6\x9B\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a \xA0W__\xFD[PZ\xFA\x15\x80\x15a \xB2W=__>=_\xFD[PPPPPPV[``a \xC6\x84\x84a)xV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a \xDEWa \xDEa$\xBFV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a!\x07W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x1E\xE0Wa!\xDA\x86a!!\x83a\"\x08V[\x85`@Q` \x01a!4\x93\x92\x91\x90a-\xDDV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta!P\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta!|\x90a)\xE3V[\x80\x15a!\xC7W\x80`\x1F\x10a!\x9EWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a!\xC7V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a!\xAAW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa$k\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a!\xE5\x87\x84a)xV[\x81Q\x81\x10a!\xF5Wa!\xF5a)\x8BV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a!\x0CV[``\x81_\x03a\"JWPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\"sW\x80a\"]\x81a.zV[\x91Pa\"l\x90P`\n\x83a.\xDEV[\x91Pa\"MV[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\"\x8DWa\"\x8Da$\xBFV[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\"\xB7W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x03UWa\"\xCC`\x01\x83a)xV[\x91Pa\"\xD9`\n\x86a.\xF1V[a\"\xE4\x90`0a/\x04V[`\xF8\x1B\x81\x83\x81Q\x81\x10a\"\xF9Wa\"\xF9a)\x8BV[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa#2`\n\x86a.\xDEV[\x94Pa\"\xBBV[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a#\x8E\x90\x86\x90\x86\x90`\x04\x01a/\x17V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a#\xA8W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra#\xCF\x91\x90\x81\x01\x90a/DV[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a$,\x90\x86\x90\x86\x90`\x04\x01a/\x17V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a$GW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a#\xCF\x91\x90a,=V[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a$,\x90\x86\x90\x86\x90`\x04\x01a/\x17V[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a%\x15Wa%\x15a$\xBFV[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a%6Wa%6a$\xBFV[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a%VW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a%lW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a%|W__\xFD[\x805a%\x8Fa%\x8A\x82a%\x1DV[a$\xECV[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a%\xA3W__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a&PW`?\x19\x87\x86\x03\x01\x84Ra&;\x85\x83Qa%\xCBV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a&\x1FV[P\x92\x96\x95PPPPPPV[` \x81R_a#\xCF` \x83\x01\x84a%\xCBV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a&\xBBW\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&\x87V[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a'\x14W`\x1F\x19\x85\x84\x03\x01\x88Ra&\xFE\x83\x83Qa%\xCBV[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a&\xE2V[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a&PW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra'\x8E`@\x87\x01\x82a&\xC6V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a'FV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a&\xBBW\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a'\xBDV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a(-W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a'\xEDV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a&PW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra(\x83`@\x88\x01\x82a%\xCBV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra(\x9E\x81\x83a'\xDBV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a(]V[` \x81R_a#\xCF` \x83\x01\x84a&\xC6V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a&PW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra)5`@\x87\x01\x82a'\xDBV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a(\xEDV[\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#\xD2Wa#\xD2a)KV[\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x03Ua)\xDD\x83\x86a)\xB8V[\x84a)\xB8V[`\x01\x81\x81\x1C\x90\x82\x16\x80a)\xF7W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a*.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`\"`\x04R`$_\xFD[P\x91\x90PV[\x80T_\x90`\x01\x81\x81\x1C\x90\x82\x16\x80a*LW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a*\x83W\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[\x81\x86R` \x86\x01\x81\x80\x15a*\x9EW`\x01\x81\x14a*\xD2Wa*\xFEV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x85\x16\x82R\x83\x15\x15`\x05\x1B\x82\x01\x95Pa*\xFEV[_\x87\x81R` \x90 _[\x85\x81\x10\x15a*\xF8W\x81T\x84\x82\x01R`\x01\x90\x91\x01\x90` \x01a*\xDCV[\x83\x01\x96PP[PPPPP\x92\x91PPV[\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\x81T`\xE0\x1B\x16\x82R`\x80` \x83\x01R_a+J`\x80\x84\x01`\x01\x84\x01a*4V[\x83\x81\x03`@\x85\x01Ra+_\x81`\x02\x85\x01a*4V[\x90P\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`\x03\x84\x01T`\xE0\x1B\x16``\x85\x01R\x80\x91PP\x92\x91PPV[`\xA0\x82R_a+\xAC`\xA0\x84\x01\x83a*4V[`\x01\x83\x01T` \x85\x01R\x83\x81\x03`@\x85\x01Ra+\xCB\x81`\x02\x85\x01a*4V[\x90P`\x03\x83\x01T``\x85\x01R\x83\x81\x03`\x80\x85\x01Ra\x03U\x81`\x04\x85\x01a*4V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x81R\x83` \x82\x01R`\x80`@\x82\x01R_a, `\x80\x83\x01\x85a+\tV[\x82\x81\x03``\x84\x01Ra,2\x81\x85a+\x9AV[\x97\x96PPPPPPPV[_` \x82\x84\x03\x12\x15a,MW__\xFD[PQ\x91\x90PV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x81R\x83` \x82\x01R`\x80`@\x82\x01R\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\x83Q\x16`\x80\x82\x01R_` \x84\x01Q`\x80`\xA0\x84\x01Ra,\xBEa\x01\0\x84\x01\x82a%\xCBV[\x90P`@\x85\x01Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x84\x83\x03\x01`\xC0\x85\x01Ra,\xF9\x82\x82a%\xCBV[\x91PP\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``\x86\x01Q\x16`\xE0\x84\x01R\x82\x81\x03``\x84\x01Ra,2\x81\x85a+\x9AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x81R\x83` \x82\x01R`\x80`@\x82\x01R_a-n`\x80\x83\x01\x85a+\tV[\x82\x81\x03``\x84\x01R\x83Q`\xA0\x82Ra-\x89`\xA0\x83\x01\x82a%\xCBV[\x90P` \x85\x01Q` \x83\x01R`@\x85\x01Q\x82\x82\x03`@\x84\x01Ra-\xAC\x82\x82a%\xCBV[\x91PP``\x85\x01Q``\x83\x01R`\x80\x85\x01Q\x82\x82\x03`\x80\x84\x01Ra-\xD0\x82\x82a%\xCBV[\x99\x98PPPPPPPPPV[\x7F.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R_a.\x0E`\x01\x83\x01\x86a)\xB8V[\x7F[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra.>`\x01\x82\x01\x86a)\xB8V[\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\x81Ra.p`\x02\x82\x01\x85a)\xB8V[\x96\x95PPPPPPV[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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.\xAAWa.\xAAa)KV[P`\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`\x12`\x04R`$_\xFD[_\x82a.\xECWa.\xECa.\xB1V[P\x04\x90V[_\x82a.\xFFWa.\xFFa.\xB1V[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a#\xD2Wa#\xD2a)KV[`@\x81R_a/)`@\x83\x01\x85a%\xCBV[\x82\x81\x03` \x84\x01Ra/;\x81\x85a%\xCBV[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a/TW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a/jW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a/zW__\xFD[\x80Qa/\x88a%\x8A\x82a%\x1DV[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a/\x9CW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV\xFETx merkle proof is not valid for provided header and tx hash\0\0\0 s\xBD!\x84\xED\xD9\xC4\xFCvd.\xA6uN\xE4\x016\x97\x0E\xFC\x10\xC4\x19\0\0\0\0\0\0\0\0\0\x02\x96\xEF\x12>\xA9m\xA5\xCFi_\"\xBF}\x94\xBE\x87\xD4\x9D\xB1\xADz\xC3q\xACC\xC4\xDAAa\xC8\xC2\x164\x9C[\xA1\x19(\x17\r8x\xA2dipfsX\"\x12 \xFD\xEF6P\xB6\x97\xA7\xD9\xFF\xBA\x1AV\xB5\x97\x15\xEF\x8F\xC9\xA3K\xAF\x19\xFB}\x99\xDEWQ\xFF\xCA\x90\x84dsolcC\0\x08\x1C\x003`\x80`@R4\x80\x15`\x0EW__\xFD[Pa\x0F\xDD\x80a\0\x1C_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0)W_5`\xE0\x1C\x80c-y\xDBF\x14a\0-W[__\xFD[a\0@a\0;6`\x04a\r(V[a\0RV[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[_a\0_\x85\x85\x85\x85a\0jV[\x90P[\x94\x93PPPPV[_a\0t\x83a\0\x8FV[\x90Pa\0\x80\x81\x83a\x01\x8AV[a\0b\x85\x85\x84`@\x01Qa\x03\xF4V[_a\0\x9D\x82` \x01Qa\x04\xDBV[a\0\xEEW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FInvalid input vector provided\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\0\xFB\x82`@\x01Qa\x05uV[a\x01GW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FInvalid output vector provided\0\0`D\x82\x01R`d\x01a\0\xE5V[a\x01\x84\x82_\x01Q\x83` \x01Q\x84`@\x01Q\x85``\x01Q`@Q` \x01a\x01p\x94\x93\x92\x91\x90a\x0EXV[`@Q` \x81\x83\x03\x03\x81R\x90`@Ra\x06\x02V[\x92\x91PPV[\x80Qa\x01\x95\x90a\x06$V[a\x01\xE1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7FBad merkle array proof\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\0\xE5V[`\x80\x81\x01QQ\x81QQ\x14a\x02]W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`/`$\x82\x01R\x7FTx not on same level of merkle t`D\x82\x01R\x7Free as coinbase\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\0\xE5V[_a\x02k\x82`@\x01Qa\x06:V[\x82Q` \x84\x01Q\x91\x92Pa\x02\x82\x91\x85\x91\x84\x91a\x06FV[a\x02\xF4W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`<`$\x82\x01R\x7FTx merkle proof is not valid for`D\x82\x01R\x7F provided header and tx hash\0\0\0\0`d\x82\x01R`\x84\x01a\0\xE5V[_`\x02\x83``\x01Q`@Q` \x01a\x03\x0E\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x03(\x91a\x0E\xC7V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x03CW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03f\x91\x90a\x0E\xD2V[`\x80\x84\x01Q\x90\x91Pa\x03|\x90\x82\x90\x84\x90_a\x06FV[a\x03\xEEW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`?`$\x82\x01R\x7FCoinbase merkle proof is not val`D\x82\x01R\x7Fid for provided header and hash\0`d\x82\x01R`\x84\x01a\0\xE5V[PPPPV[\x80Q`P\x14a\x04EW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FBad header block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\0\xE5V[_a\x04O\x82a\x06xV[`@Q\x7F\xE4q\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\x81\x01\x82\x90R`\xFF\x85\x16`$\x82\x01R\x90\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x90c\xE4q\xE7,\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x04\xBFW__\xFD[PZ\xFA\x15\x80\x15a\x04\xD1W=__>=_\xFD[PPPPPPPPV[___a\x04\xE7\x84a\x072V[\x90\x92P\x90P\x80\x15\x80a\x04\xF9WP_\x19\x82\x14[\x15a\x05\x07WP_\x93\x92PPPV[_a\x05\x13\x83`\x01a\x0F\x16V[\x90P_[\x82\x81\x10\x15a\x05hW\x85Q\x82\x10a\x052WP_\x95\x94PPPPPV[_a\x05=\x87\x84a\x07GV[\x90P_\x19\x81\x03a\x05SWP_\x96\x95PPPPPPV[a\x05]\x81\x84a\x0F\x16V[\x92PP`\x01\x01a\x05\x17V[P\x93Q\x90\x93\x14\x93\x92PPPV[___a\x05\x81\x84a\x072V[\x90\x92P\x90P\x80\x15\x80a\x05\x93WP_\x19\x82\x14[\x15a\x05\xA1WP_\x93\x92PPPV[_a\x05\xAD\x83`\x01a\x0F\x16V[\x90P_[\x82\x81\x10\x15a\x05hW\x85Q\x82\x10a\x05\xCCWP_\x95\x94PPPPPV[_a\x05\xD7\x87\x84a\x07\x96V[\x90P_\x19\x81\x03a\x05\xEDWP_\x96\x95PPPPPPV[a\x05\xF7\x81\x84a\x0F\x16V[\x92PP`\x01\x01a\x05\xB1V[_` _\x83Q` \x85\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x91\x90PV[_` \x82Qa\x063\x91\x90a\x0F)V[\x15\x92\x91PPV[`D\x81\x01Q_\x90a\x01\x84V[_\x83\x85\x14\x80\x15a\x06TWP\x81\x15[\x80\x15a\x06_WP\x82Q\x15[\x15a\x06lWP`\x01a\0bV[a\0_\x85\x84\x86\x85a\x07\xF6V[_`\x02\x80\x83`@Qa\x06\x8A\x91\x90a\x0E\xC7V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x06\xA5W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xC8\x91\x90a\x0E\xD2V[`@Q` \x01a\x06\xDA\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x06\xF4\x91a\x0E\xC7V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x07\x0FW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\x84\x91\x90a\x0E\xD2V[__a\x07>\x83_a\x08\x9BV[\x91P\x91P\x91P\x91V[___a\x07T\x85\x85a\n8V[\x90\x92P\x90P`\x01\x82\x01a\x07lW_\x19\x92PPPa\x01\x84V[\x80a\x07x\x83`%a\x0F\x16V[a\x07\x82\x91\x90a\x0F\x16V[a\x07\x8D\x90`\x04a\x0F\x16V[\x95\x94PPPPPV[_a\x07\xA2\x82`\ta\x0F\x16V[\x83Q\x10\x15a\x07\xB2WP_\x19a\x01\x84V[_\x80a\x07\xC8\x85a\x07\xC3\x86`\x08a\x0F\x16V[a\x08\x9BV[\x90\x92P\x90P`\x01\x82\x01a\x07\xE0W_\x19\x92PPPa\x01\x84V[\x80a\x07\xEC\x83`\ta\x0F\x16V[a\x07\x8D\x91\x90a\x0F\x16V[_` \x84Qa\x08\x05\x91\x90a\x0F)V[\x15a\x08\x11WP_a\0bV[\x83Q_\x03a\x08 WP_a\0bV[\x81\x85_[\x86Q\x81\x10\x15a\x08\x8EWa\x088`\x02\x84a\x0F)V[`\x01\x03a\x08\\Wa\x08Ua\x08O\x88\x83\x01` \x01Q\x90V[\x83a\nvV[\x91Pa\x08uV[a\x08r\x82a\x08m\x89\x84\x01` \x01Q\x90V[a\nvV[\x91P[`\x01\x92\x90\x92\x1C\x91a\x08\x87` \x82a\x0F\x16V[\x90Pa\x08$V[P\x90\x93\x14\x95\x94PPPPPV[___a\x08\xA8\x85\x85a\n\x88V[\x90P\x80`\xFF\x16_\x03a\x08\xDBW_\x85\x85\x81Q\x81\x10a\x08\xC7Wa\x08\xC7a\x0FaV[\x01` \x01Q\x90\x93P`\xF8\x1C\x91Pa\n1\x90PV[\x83a\x08\xE7\x82`\x01a\x0F\x8EV[`\xFF\x16a\x08\xF4\x91\x90a\x0F\x16V[\x85Q\x10\x15a\t\tW_\x19_\x92P\x92PPa\n1V[_\x81`\xFF\x16`\x02\x03a\tLWa\tAa\t-a\t&\x87`\x01a\x0F\x16V[\x88\x90a\x0B\x0CV[b\xFF\xFF\0`\xE8\x82\x90\x1C\x16`\xF8\x91\x90\x91\x1C\x17\x90V[a\xFF\xFF\x16\x90Pa\n'V[\x81`\xFF\x16`\x04\x03a\t\x9BWa\t\x8Ea\tha\t&\x87`\x01a\x0F\x16V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[c\xFF\xFF\xFF\xFF\x16\x90Pa\n'V[\x81`\xFF\x16`\x08\x03a\n'Wa\n\x1Aa\t\xB7a\t&\x87`\x01a\x0F\x16V[`\xC0\x1Cd\xFF\0\0\0\xFF`\x08\x82\x81\x1C\x91\x82\x16e\xFF\0\0\0\xFF\0\x93\x90\x91\x1B\x92\x83\x16\x17`\x10\x90\x81\x1Bg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16f\xFF\0\xFF\0\xFF\0\xFF\x92\x90\x92\x16g\xFF\0\xFF\0\xFF\0\xFF\0\x90\x93\x16\x92\x90\x92\x17\x90\x91\x1Ce\xFF\xFF\0\0\xFF\xFF\x16\x17` \x81\x81\x1C\x91\x90\x1B\x17\x90V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P[`\xFF\x90\x91\x16\x92P\x90P[\x92P\x92\x90PV[_\x80a\nE\x83`%a\x0F\x16V[\x84Q\x10\x15a\nXWP_\x19\x90P_a\n1V[_\x80a\ni\x86a\x07\xC3\x87`$a\x0F\x16V[\x90\x97\x90\x96P\x94PPPPPV[_a\n\x81\x83\x83a\x0B\x1AV[\x93\x92PPPV[_\x82\x82\x81Q\x81\x10a\n\x9BWa\n\x9Ba\x0FaV[\x01` \x01Q`\xF8\x1C`\xFF\x03a\n\xB2WP`\x08a\x01\x84V[\x82\x82\x81Q\x81\x10a\n\xC4Wa\n\xC4a\x0FaV[\x01` \x01Q`\xF8\x1C`\xFE\x03a\n\xDBWP`\x04a\x01\x84V[\x82\x82\x81Q\x81\x10a\n\xEDWa\n\xEDa\x0FaV[\x01` \x01Q`\xF8\x1C`\xFD\x03a\x0B\x04WP`\x02a\x01\x84V[P_\x92\x91PPV[_a\n\x81\x83\x83\x01` \x01Q\x90V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\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`A`\x04R`$_\xFD[`@Q`\xA0\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0B\x91Wa\x0B\x91a\x0BAV[`@R\x90V[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0B\x91Wa\x0B\x91a\x0BAV[\x805\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\x0B\xE9W__\xFD[\x91\x90PV[_\x82`\x1F\x83\x01\x12a\x0B\xFDW__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0C\x17Wa\x0C\x17a\x0BAV[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0CFWa\x0CFa\x0BAV[`@R\x81\x81R\x83\x82\x01` \x01\x85\x10\x15a\x0C]W__\xFD[\x81` \x85\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[_`\xA0\x82\x84\x03\x12\x15a\x0C\x89W__\xFD[a\x0C\x91a\x0BnV[\x90P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0C\xA9W__\xFD[a\x0C\xB5\x84\x82\x85\x01a\x0B\xEEV[\x82RP` \x82\x81\x015\x90\x82\x01R`@\x82\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0C\xDBW__\xFD[a\x0C\xE7\x84\x82\x85\x01a\x0B\xEEV[`@\x83\x01RP``\x82\x81\x015\x90\x82\x01R`\x80\x82\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\x10W__\xFD[a\r\x1C\x84\x82\x85\x01a\x0B\xEEV[`\x80\x83\x01RP\x92\x91PPV[____`\x80\x85\x87\x03\x12\x15a\r;W__\xFD[\x845s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\r^W__\xFD[\x93P` \x85\x015\x92P`@\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\x80W__\xFD[\x85\x01`\x80\x81\x88\x03\x12\x15a\r\x91W__\xFD[a\r\x99a\x0B\x97V[a\r\xA2\x82a\x0B\xBAV[\x81R` \x82\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\xBDW__\xFD[a\r\xC9\x89\x82\x85\x01a\x0B\xEEV[` \x83\x01RP`@\x82\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\xE8W__\xFD[a\r\xF4\x89\x82\x85\x01a\x0B\xEEV[`@\x83\x01RPa\x0E\x06``\x83\x01a\x0B\xBAV[``\x82\x01R\x80\x93PPP``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0E)W__\xFD[a\x0E5\x87\x82\x88\x01a\x0CyV[\x91PP\x92\x95\x91\x94P\x92PV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[\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\x85\x16\x81R_a\x0E\x94a\x0E\x8E`\x04\x84\x01\x87a\x0EAV[\x85a\x0EAV[\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\x93\x90\x93\x16\x83RPP`\x04\x01\x93\x92PPPV[_a\n\x81\x82\x84a\x0EAV[_` \x82\x84\x03\x12\x15a\x0E\xE2W__\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\x01\x84Wa\x01\x84a\x0E\xE9V[_\x82a\x0F\\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`\x12`\x04R`$_\xFD[P\x06\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[`\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x01\x84Wa\x01\x84a\x0E\xE9V\xFE\xA2dipfsX\"\x12 \x014G\x13\xD0r\xB6\x95\x9D}<-\xC4\xEA\xFCA(\0\x9F\x0BJy\x16)P\xB4\x1Dv\xED\xE7\xB7ddsolcC\0\x08\x1C\x003`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa);8\x03\x80a);\x839\x81\x01`@\x81\x90Ra\0.\x91a\x03+V[\x82\x82\x82\x82\x82\x82a\0?\x83Q`P\x14\x90V[a\0\x84W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x11`$\x82\x01RpBad genesis block`x\x1B`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\0\x8E\x84a\x01fV[\x90Pb\xFF\xFF\xFF\x82\x16\x15a\x01\tW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FPeriod start hash does not have `D\x82\x01R\x7Fwork. Hint: wrong byte order?\0\0\0`d\x82\x01R`\x84\x01a\0{V[_\x81\x81U`\x01\x82\x90U`\x02\x82\x90U\x81\x81R`\x04` R`@\x90 \x83\x90Ua\x012a\x07\xE0\x84a\x03\xFEV[a\x01<\x90\x84a\x04%V[_\x83\x81R`\x04` R`@\x90 Ua\x01S\x84a\x02&V[`\x05UPa\x05\xBD\x98PPPPPPPPPV[_`\x02\x80\x83`@Qa\x01x\x91\x90a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\x93W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x04NV[`@Q` \x01a\x01\xC8\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x01\xE2\x91a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\xFDW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02 \x91\x90a\x04NV[\x92\x91PPV[_a\x02 a\x023\x83a\x028V[a\x02CV[_a\x02 \x82\x82a\x02SV[_a\x02 a\xFF\xFF`\xD0\x1B\x83a\x02\xF7V[_\x80a\x02ja\x02c\x84`Ha\x04eV[\x85\x90a\x03\tV[`\xE8\x1C\x90P_\x84a\x02|\x85`Ka\x04eV[\x81Q\x81\x10a\x02\x8CWa\x02\x8Ca\x04xV[\x01` \x01Q`\xF8\x1C\x90P_a\x02\xBE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x02\xD1`\x03\x84a\x04\x8CV[`\xFF\x16\x90Pa\x02\xE2\x81a\x01\0a\x05\x88V[a\x02\xEC\x90\x83a\x05\x93V[\x97\x96PPPPPPPV[_a\x03\x02\x82\x84a\x05\xAAV[\x93\x92PPPV[_a\x03\x02\x83\x83\x01` \x01Q\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x03=W__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03RW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03bW__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03{Wa\x03{a\x03\x17V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x03\xA9Wa\x03\xA9a\x03\x17V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x03\xC0W__\xFD[\x81` \x84\x01` \x83\x01^_` \x92\x82\x01\x83\x01R\x90\x86\x01Q`@\x90\x96\x01Q\x90\x97\x95\x96P\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x04\x0CWa\x04\x0Ca\x03\xEAV[P\x06\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x04^W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02 Wa\x02 a\x04\x11V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[`\x01\x81[`\x01\x84\x11\x15a\x04\xE0W\x80\x85\x04\x81\x11\x15a\x04\xC4Wa\x04\xC4a\x04\x11V[`\x01\x84\x16\x15a\x04\xD2W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x04\xA9V[\x93P\x93\x91PPV[_\x82a\x04\xF6WP`\x01a\x02 V[\x81a\x05\x02WP_a\x02 V[\x81`\x01\x81\x14a\x05\x18W`\x02\x81\x14a\x05\"Wa\x05>V[`\x01\x91PPa\x02 V[`\xFF\x84\x11\x15a\x053Wa\x053a\x04\x11V[PP`\x01\x82\x1Ba\x02 V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x05aWP\x81\x81\na\x02 V[a\x05m_\x19\x84\x84a\x04\xA5V[\x80_\x19\x04\x82\x11\x15a\x05\x80Wa\x05\x80a\x04\x11V[\x02\x93\x92PPPV[_a\x03\x02\x83\x83a\x04\xE8V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x02 Wa\x02 a\x04\x11V[_\x82a\x05\xB8Wa\x05\xB8a\x03\xEAV[P\x04\x90V[a#q\x80a\x05\xCA_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\xADW\x80c\xB9\x85b\x1A\x11a\0}W\x80c\xE3\xD8\xD8\xD8\x11a\0cW\x80c\xE3\xD8\xD8\xD8\x14a\x02\"W\x80c\xE4q\xE7,\x14a\x02)W\x80c\xF5\x8D\xB0o\x14a\x02=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x13\x91\x90a!WV[`@Q` \x01a\x0C%\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\x90\x82\x90Ra\x0C]\x91a!AV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0CxW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x07\x91\x90a!WV[_\x83\x85\x14\x80\x15a\x0C\xAAWP\x82\x85\x14[\x15a\x0C\xB7WP`\x01a\x04\xF1V[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x0C\xFFW\x89\x83\x14a\x0C\xDEW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x0C\xF7W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x0C\xBDV[P\x82\x84\x03a\r\x13W_\x94PPPPPa\x04\xF1V[\x80\x82\x14a\r&W_\x94PPPPPa\x04\xF1V[P`\x01\x98\x97PPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\rYW_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\r9V[P\x80a\x05\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x80\x82\x81[a\r\xB8`\x04`\x01a!\x9BV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0E\x0CW_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\r\xF1W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0E\x04V[a\r\xFB\x81\x84a!\xB7V[\x95\x94PPPPPV[`\x01\x01a\r\xACV[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_`P\x82Qa\x0B~\x91\x90a!.V[__a\x0Eo\x85a\x0B\xC3V[\x90P_a\x0E{\x82a\r\xA7V[\x90P_a\x0E\x87\x86a\x19\xE6V[\x90P\x84\x80a\x0E\x9CWP\x80a\x0E\x9A\x88a\x19\xE6V[\x14[a\x0F\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x03.V[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x12\x0EWa\x0F(`P\x82a!\xCAV[a\x0F3\x90`\x01a!\xB7V[a\x0F=\x90\x87a!\xB7V[\x93Pa\x0FK\x8A\x82`Pa\x19\xF1V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x11!W\x84a\x10\xA1\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x10\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x11\n`\x04\x85a!.V[_\x03a\x11!W_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x11,\x8B\x83a\x1A\x16V[\x14a\x11yW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[\x86a\x11\x84\x8B\x83a\x1A\xAFV[\x14a\x11\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x03.V[\x82\x96P`P\x81a\x12\x07\x91\x90a!\xB7V[\x90Pa\x0F\x15V[P\x81a\x12\x19\x8Ba\x0B\xC3V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x12\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x12\xD4\x84a\x0B\xC3V[\x90P_a\x12\xE0\x86a\x0B\xC3V[\x90P`\x01T\x81\x14a\x133W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x03.V[_\x82\x81R`\x03` R`@\x90 Ta\x13\x8DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x13\x9B\x87`\x01T\x84\x87a\x0C\x9BV[a\x14\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x03.V[\x81a\x14\x19\x88\x88\x88a\x17\x80V[\x14a\x14\x8CW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[`\x01\x82\x90U`\x02\x87\x90U_a\x14\xA0\x86a\x1A\xC7V[\x90P`\x05T\x81\x14a\x14\xB1W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x15\x01a\x14\xFC\x86a\x0B\xC3V[a\r\xA7V[\x90P_a\x15\x10a\x14\xFC\x86a\x0B\xC3V[\x90Pa\x15\x1Ea\x07\xE0\x82a!.V[a\x07\xDF\x14a\x15\x94W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x03.V[a\x15\xA0\x82a\x07\xDFa!\xB7V[\x81\x14a\x16\x14W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x03.V[a\x16\x1D\x85a\x1A\xC7V[a\x16&\x87a\x1A\xC7V[\x14a\x16\x99W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x03.V[_a\x16\xA3\x85a\x19\xE6V[\x90P_a\x16\xD5a\x16\xB2\x89a\x19\xE6V[a\x16\xBB\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x16\xCA\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x1B\x0CV[\x90P\x81\x81\x83\x16\x14a\x17(W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_a\x172\x89a\x1A\xC7V[\x90P\x80`\x06T\x14\x15\x80\x15a\x17\\WPa\x07\xE0a\x17O`\x01Ta\r\xA7V[a\x17Y\x91\x90a!\xDDV[\x84\x11[\x15a\x17gW`\x06\x81\x90U[a\x17s\x88\x88`\x01a\x0EdV[\x99\x98PPPPPPPPPV[__a\x17\x8B\x85a\r\xA7V[\x90P_a\x17\x9Aa\x14\xFC\x86a\x0B\xC3V[\x90P_a\x17\xA9a\x14\xFC\x86a\x0B\xC3V[\x90P\x82\x82\x10\x15\x80\x15a\x17\xBBWP\x82\x81\x10\x15[a\x18-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x18:a\x07\xE0\x85a!.V[a\x18F\x85a\x07\xE0a!\xB7V[a\x18P\x91\x90a!\xDDV[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x18bWP\x80[\x15a\x18}Wa\x18p\x89a\x0B\xC3V[\x96PPPPPPPa\n\xA3V[\x81\x80\x15a\x18\x88WP\x80\x15[\x15a\x18\x96Wa\x18p\x88a\x0B\xC3V[\x81\x80\x15a\x18\xA0WP\x80[\x15a\x18\xC4W\x83\x85\x10\x15a\x18\xBBWa\x18\xB6\x88a\x0B\xC3V[a\x18pV[a\x18p\x89a\x0B\xC3V[a\x18\xCD\x88a\x1A\xC7V[a\x18\xD9a\x07\xE0\x86a!.V[a\x18\xE3\x91\x90a!\xF0V[a\x18\xEC\x8Aa\x1A\xC7V[a\x18\xF8a\x07\xE0\x88a!.V[a\x19\x02\x91\x90a!\xF0V[\x10\x15a\x18\xBBWa\x18p\x88a\x0B\xC3V[`\x07T_\x90`\xFF\x16\x15a\x19/WP`\x07Ta\x01\0\x90\x04`\xFF\x16a\n\xA3V[a\x19:\x84\x84\x84a\x1B\x94V[\x90Pa\n\xA3V[_` \x84Qa\x19P\x91\x90a!.V[\x15a\x19\\WP_a\x04\xF1V[\x83Q_\x03a\x19kWP_a\x04\xF1V[\x81\x85_[\x86Q\x81\x10\x15a\x19\xD9Wa\x19\x83`\x02\x84a!.V[`\x01\x03a\x19\xA7Wa\x19\xA0a\x19\x9A\x88\x83\x01` \x01Q\x90V[\x83a\x1B\xD5V[\x91Pa\x19\xC0V[a\x19\xBD\x82a\x19\xB8\x89\x84\x01` \x01Q\x90V[a\x1B\xD5V[\x91P[`\x01\x92\x90\x92\x1C\x91a\x19\xD2` \x82a!\xB7V[\x90Pa\x19oV[P\x90\x93\x14\x95\x94PPPPPV[_a\x05\x07\x82_a\x1A\x16V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x1A-a\x1A&\x84`Ha!\xB7V[\x85\x90a\x1B\xE0V[`\xE8\x1C\x90P_\x84a\x1A?\x85`Ka!\xB7V[\x81Q\x81\x10a\x1AOWa\x1AOa\"\x07V[\x01` \x01Q`\xF8\x1C\x90P_a\x1A\x81\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1A\x94`\x03\x84a\"4V[`\xFF\x16\x90Pa\x1A\xA5\x81a\x01\0a#0V[a\x08-\x90\x83a!\xF0V[_a\x05\x04a\x1A\xBE\x83`\x04a!\xB7V[\x84\x01` \x01Q\x90V[_a\x05\x07a\x1A\xD4\x83a\x19\xE6V[a\x1B\xEEV[_a\x05\x07a\x1A\xE6\x83a\x1C\x15V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1B\x18\x83\x85a\x1C!V[\x90Pa\x1B(b\x12u\0`\x04a\x1C|V[\x81\x10\x15a\x1B@Wa\x1B=b\x12u\0`\x04a\x1C|V[\x90P[a\x1BNb\x12u\0`\x04a\x1C\x87V[\x81\x11\x15a\x1BfWa\x1Bcb\x12u\0`\x04a\x1C\x87V[\x90P[_a\x1B~\x82a\x1Bx\x88b\x01\0\0a\x1C|V[\x90a\x1C\x87V[\x90Pa\n\x8Ab\x01\0\0a\x1Bx\x83b\x12u\0a\x1C|V[_\x82\x81[\x83\x81\x10\x15a\x1B\xCAW\x85\x82\x03a\x1B\xB2W`\x01\x92PPPa\n\xA3V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x1B\x98V[P_\x95\x94PPPPPV[_a\x05\x04\x83\x83a\x1C\xFAV[_a\x05\x04\x83\x83\x01` \x01Q\x90V[_a\x05\x07{\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\x83a\x1C|V[_a\x05\x07\x82`Da\x1B\xE0V[_\x82\x82\x11\x15a\x1CrW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x05\x04\x82\x84a!\xDDV[_a\x05\x04\x82\x84a!\xCAV[_\x82_\x03a\x1C\x96WP_a\x05\x07V[a\x1C\xA0\x82\x84a!\xF0V[\x90P\x81a\x1C\xAD\x84\x83a!\xCAV[\x14a\x05\x07W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x03.V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1D1W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DHW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1D_W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1DvW__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1D\x91W__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xA7W__\xFD[a\x1D\xB3\x8A\x82\x8B\x01a\x1D!V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xD2W__\xFD[a\x1D\xDE\x8A\x82\x8B\x01a\x1D!V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1D\xFE`\x80\x89\x01a\x1DfV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[____`\x80\x85\x87\x03\x12\x15a\x1E\x1FW__\xFD[PP\x825\x94` \x84\x015\x94P`@\x84\x015\x93``\x015\x92P\x90PV[__`@\x83\x85\x03\x12\x15a\x1ELW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1EkW__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1E\x85W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x9BW__\xFD[a\x1E\xA7\x87\x82\x88\x01a\x1D!V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\xC6W__\xFD[a\x1E\xD2\x87\x82\x88\x01a\x1D!V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1E\xF3W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x10W__\xFD[a\x1F\x1C\x89\x82\x8A\x01a\x1D!V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F;W__\xFD[a\x1FG\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1FtW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x8AW__\xFD[a\x1F\x96\x89\x82\x8A\x01a\x1D!V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xB5W__\xFD[a\x1F\xC1\x89\x82\x8A\x01a\x1D!V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xE0W__\xFD[a\x1F\xEC\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_____``\x86\x88\x03\x12\x15a \x12W__\xFD[\x855\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a /W__\xFD[a ;\x88\x82\x89\x01a\x1D!V[\x90\x95P\x93PP`@\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a ZW__\xFD[a f\x88\x82\x89\x01a\x1D!V[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[___``\x84\x86\x03\x12\x15a \x89W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a \xB1W__\xFD[\x825\x91Pa \xC1` \x84\x01a\x1DfV[\x90P\x92P\x92\x90PV[\x805\x80\x15\x15\x81\x14a\x1DvW__\xFD[__`@\x83\x85\x03\x12\x15a \xEAW__\xFD[a \xF3\x83a \xCAV[\x91Pa \xC1` \x84\x01a \xCAV[\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!\xA9m\xA5\xCFi_\"\xBF}\x94\xBE\x87\xD4\x9D\xB1\xADz\xC3q\xACC\xC4\xDAAa\xC8\xC2\x164\x9C[\xA1\x19(\x17\r8x+\0\0\0\0\0\0\0\0\0\0\0\0q\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x02H\x97\x07\0\0\0\0\0\"\0 \xA43>V\x12\xAB\x1A\x10C\xB2WU\xC8\x9B\x16\xD5Q\x84\xA4/\x81y\x9Eb>k\xC3\x9D\xB8S\x9C\x18\0\0\0\0\0\0\0\0\x16j\x14\xED\xB1\xB5\xC2\xF3\x9A\xF0\xFE\xC1Qs%\x85\xB1\x04\x9B\x07\x89R\x11H\xE5\xA1\xA0\xE6\x16\xD8\xFD\x92\xB4\xEF\"\x8CBN\x0C\x81g\x99\xA2V\xC6\xA9\x08\x92\x19\\\xCF\xC53\0\xD6\xE3Z\rm\xE9Kef\x94X\x99d\xA2R\x95~Fs\xA9\xFB\x1D/\x8BJ\x92\xE3\xF0\xA7\xBBeO\xDD\xB9NZ\x1Em\x7F\x7FI\x9F\xD1\xBE]\xD3\ns\xBFU\x84\xBF\x13}\xA5\xFD\xD7|\xC2\x1A\xEB\x95\xB9\xE3W\x88\x89K\xE0\x19(K\xD4\xFB\xEDm\xD6\x11\x8A\xC2\xCBm&\xBCK\xE4\xE4#\xF5Z:H\xF2\x87M\x8D\x02\xA6]\x9C\x87\xD0}\xE2\x1DM\xFE{\n\x9FJ#\xCC\x9AX7>\x9Ei1\xFE\xFD\xB5\xAF\xAD\xE5\xDFT\xC9\x11\x04\x04\x8D\xF1\xEE\x99\x92@ay\x84\xE1\x8Bo\x93\x1E#sg=\x01\x95\xB8\xC6\x98}\x7F\xF7e\r\\\xE5;\xCE\xC4n\x13\xABO-\xA1\x14j\x7F\xC6!\xEEg/b\xBC\"t$\x869-u\xE5^g\xB0\x99`\xC38j\x0BI\xE7_\x17#\xD6\xAB(\xAC\x9A (\xA0\xC7(f\xE2\x11\x1Dy\xD4\x81{\x88\xE1|\x82\x197\x84wh\xD9(7\xBA\xE3\x83+\xB8\xE5\xA4\xABD4\xB9~\0\xA6\xC1\x01\x82\xF2\x11\xF5\x92@\x90h\xD6\xF5e$\0\xD9\xA3\xD1\xCC\x15\n\x7F\xB6\x92\xE8t\xCCB\xD7k\xDA\xFC\x84//\xE0\xF85\xA7\xC2M-`\xC1\t\xB1\x87\xD6Eq\xEF\xBA\xA8\x04{\xE8X!\xF8\xE6~\x0E\x85\xF2\xF5\x89K\xC6=\0\xC2\xED\x9Dd\x01\x17F\xBD\x86t\0\xF3IK\x8FD\xC2K\x83\xE1\xAAX\xC4\xF0\xFF%\xB4\xA6\x1C\xFF\xEF\xFDK\xC0\xF9\xBA0\0\0\0\0\0\xFF\xFF\xFF\xFF\xDC \xDA\xDE\xF4w\xFA\xAB(R\xF2\xF8\xAE\x0C\x82j\xA7\xE0\\M\xE0\xD3o\x0Ecc\x04)UH\x84\xC3q\xDAYt\xB6\xF3O\xA2\xC3Sg8\xF01\xB4\x9F4\xE0\xC9\xD0\x84\xD7(\x0F&!.9\0~\xBE\x9E\xA0\x87\x0C1'E\xB5\x81(\xA0\neW\x85\x1E\x98~\xCE\x02)M\x15o\0 3n\x15\x89(\xE8\x96B\x92d,lM\xC4i\xF3K{\xAC\xF2\xD8\xC4!\x15\xBA\xB6\xAF\xC9\x06\x7F.\xD3\x0E\x87Ir\x9Bc\xE0\x88\x9E >\xE5\x8E5Y\x03\xC1\xE7\x1Fx\xC0\x08\xDFl5\x97\xB2\xCCf\xD0\xB8\xAA\xE1\xA4\xA3<\xAAwT\x98\xE51\xCF\xB6\xAFX\xE8}\xB9\x9E\x0FSm\xD2&\xD1\x8FC\xE3\x86AH\xBA[\x7F\xAC\xA5\xC7u\xF1\x0B\xC8\x10\xC6\x02\xE1\xAF!\x95\xA3Ew\x97i!\xCE\0\x9AM\xDC\n\x07\xF6\x05\xC9k\x0F_\xCFX\x081\xEB\xBE\x01\xA3\x1F\xA2\x9B\xDE\x88F\t\xD2\x86\xDC\xCF\xA5\xBA\x8EU\x8C\xE3\x12[\xD4\xC3\xA1\x9E\x88\x8C\xF2hR(b\x02\xD2\xA7\xD3\x02\xC7^\x0F\xF5\xCA\x8F\xE7)\x9F\xB0\xD9\xD1\x13+\xF2\xC5l.;s\xDFy\x92\x86\x19=`\xC1\t\xB1\x87\xD6Eq\xEF\xBA\xA8\x04{\xE8X!\xF8\xE6~\x0E\x85\xF2\xF5\x89K\xC6=\0\xC2\xED\x9Dd", - ); - /// 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\x01\x9AW_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\xE8W\x80c\xE2\x0C\x9Fq\x11a\0\x93W\x80c\xEF>h\x12\x11a\0nW\x80c\xEF>h\x12\x14a\x02\xE2W\x80c\xF1\x1D\\\xBC\x14a\x02\xEAW\x80c\xFAv&\xD4\x14a\x02\xF2W\x80c\xFA\xD0k\x8F\x14a\x02\xFFW__\xFD[\x80c\xE2\x0C\x9Fq\x14a\x02\xD2W\x80c\xE8\x9F\x84\x19\x14a\x02\xDAW\x80c\xEDZ\x9CI\x14a\x02\xDAW__\xFD[\x80c\xB5P\x8A\xA9\x11a\0\xC3W\x80c\xB5P\x8A\xA9\x14a\x02\xAAW\x80c\xBAAO\xA6\x14a\x02\xB2W\x80c\xC8\x99\xD2A\x14a\x02\xCAW__\xFD[\x80c\x91j\x17\xC6\x14a\x02\x85W\x80c\xB0FO\xDC\x14a\x02\x9AW\x80c\xB5+ X\x14a\x02\xA2W__\xFD[\x80c?r\x86\xF4\x11a\x01HW\x80cc*\xD54\x11a\x01#W\x80cc*\xD54\x14a\x02SW\x80cf\xD9\xA9\xA0\x14a\x02[W\x80c\x85\"l\x81\x14a\x02pW__\xFD[\x80c?r\x86\xF4\x14a\x02#W\x80cD\xBA\xDB\xB6\x14a\x02+W\x80c]\xF0\xD0v\x14a\x02KW__\xFD[\x80c*\xDE8\x80\x11a\x01xW\x80c*\xDE8\x80\x14a\x01\xFCW\x80c9B_\x8F\x14a\x02\x11W\x80c>^<#\x14a\x02\x1BW__\xFD[\x80c\x08\x13\x85*\x14a\x01\x9EW\x80c\x1C\r\xA8\x1F\x14a\x01\xC7W\x80c\x1E\xD7\x83\x1C\x14a\x01\xE7W[__\xFD[a\x01\xB1a\x01\xAC6`\x04a%DV[a\x03\x12V[`@Qa\x01\xBE\x91\x90a%\xF9V[`@Q\x80\x91\x03\x90\xF3[a\x01\xDAa\x01\xD56`\x04a%DV[a\x03]V[`@Qa\x01\xBE\x91\x90a&\\V[a\x01\xEFa\x03\xCFV[`@Qa\x01\xBE\x91\x90a&nV[a\x02\x04a\x04a\x0296`\x04a%DV[a\x07\xB7V[`@Qa\x01\xBE\x91\x90a'\xA4V[a\x02\x19a\x07\xFAV[a\x02\x19a\n\xB5V[a\x02ca\r\xBFV[`@Qa\x01\xBE\x91\x90a(7V[a\x02xa\x0F8V[`@Qa\x01\xBE\x91\x90a(\xB5V[a\x02\x8Da\x10\x03V[`@Qa\x01\xBE\x91\x90a(\xC7V[a\x02\x8Da\x11\x06V[a\x02\x19a\x12\tV[a\x02xa\x12\xC6V[a\x02\xBAa\x13\x91V[`@Q\x90\x15\x15\x81R` \x01a\x01\xBEV[a\x02\x19a\x14aV[a\x01\xEFa\x16eV[a\x02\x19a\x16\xD0V[a\x02\x19a\x19@V[a\x02\x19a\x1BeV[`\x1FTa\x02\xBA\x90`\xFF\x16\x81V[a\x02>a\x03\r6`\x04a%DV[a\x1DEV[``a\x03U\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1D\x88V[\x94\x93PPPPV[``_a\x03k\x85\x85\x85a\x03\x12V[\x90P_[a\x03y\x85\x85a)xV[\x81\x10\x15a\x03\xC6W\x82\x82\x82\x81Q\x81\x10a\x03\x93Wa\x03\x93a)\x8BV[` \x02` \x01\x01Q`@Q` \x01a\x03\xAC\x92\x91\x90a)\xCFV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x03oV[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x042W` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04\x07W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05|W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x05eW\x83\x82\x90_R` _ \x01\x80Ta\x04\xDA\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05\x06\x90a)\xE3V[\x80\x15a\x05QW\x80`\x1F\x10a\x05(Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05QV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x054W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x04\xBDV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x04_V[PPPP\x90P\x90V[`@\x80Q\x80\x82\x01\x82R`\x1A\x81R\x7FInsufficient confirmations\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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`\t\x91sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x06\x08\x91`\x04\x01a&\\V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x06\x1FW__\xFD[PZ\xF1\x15\x80\x15a\x061W=__>=_\xFD[PP`%T`\x1FT`@Q\x7F-y\xDBF\0\0\0\0\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\x94Pc-y\xDBF\x93Pa\x06\x9E\x92a\x01\0\x90\x92\x04\x90\x91\x16\x90\x85\x90`(\x90`,\x90`\x04\x01a+\xECV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xB9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xDD\x91\x90a,=V[PPV[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x042W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04\x07WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x042W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04\x07WPPPPP\x90P\x90V[``a\x03U\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1E\xE9V[`@\x80Q`\x80\x81\x01\x90\x91R`(\x80T`\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\x82R`)\x80T_\x93\x92\x91` \x84\x01\x91a\x08F\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x08r\x90a)\xE3V[\x80\x15a\x08\xBDW\x80`\x1F\x10a\x08\x94Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x08\xBDV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x08\xA0W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x02\x82\x01\x80Ta\x08\xD6\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\t\x02\x90a)\xE3V[\x80\x15a\tMW\x80`\x1F\x10a\t$Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\tMV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t0W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x83RPP`\x03\x91\x90\x91\x01T`\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` \x91\x82\x01R`@\x80Q\x80\x82\x01\x82R`\x01\x81R_\x81\x84\x01R\x83\x82\x01R\x80Q\x80\x82\x01\x82R`\x1E\x81R\x7FInvalid output vector provided\0\0\x92\x81\x01\x92\x90\x92RQ\x7F\xF2\x8D\xCE\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\x91\x92Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\n\x1F\x91`\x04\x01a&\\V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\n6W__\xFD[PZ\xF1\x15\x80\x15a\nHW=__>=_\xFD[PP`%T`\x1FT`&T`@Q\x7F-y\xDBF\0\0\0\0\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\x93\x84\x16\x95Pc-y\xDBF\x94Pa\x06\x9E\x93a\x01\0\x90\x93\x04\x90\x92\x16\x91\x86\x90`,\x90`\x04\x01a,TV[_`,`@Q\x80`\xA0\x01`@R\x90\x81_\x82\x01\x80Ta\n\xD2\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n\xFE\x90a)\xE3V[\x80\x15a\x0BIW\x80`\x1F\x10a\x0B Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0BIV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B,W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01T\x81R` \x01`\x02\x82\x01\x80Ta\x0Bl\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\x98\x90a)\xE3V[\x80\x15a\x0B\xE3W\x80`\x1F\x10a\x0B\xBAWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\xE3V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xC6W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x03\x82\x01T\x81R` \x01`\x04\x82\x01\x80Ta\x0C\x06\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C2\x90a)\xE3V[\x80\x15a\x0C}W\x80`\x1F\x10a\x0CTWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C}V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0C`W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81RPP\x90P`@Q\x80`\x80\x01`@R\x80`O\x81R` \x01a/\xF6`O\x919`@\x80\x83\x01\x91\x90\x91R\x80Q\x80\x82\x01\x82R`\x10\x81R\x7FBad header block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\r)\x91\x90`\x04\x01a&\\V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\r@W__\xFD[PZ\xF1\x15\x80\x15a\rRW=__>=_\xFD[PP`%T`\x1FT`&T`@Q\x7F-y\xDBF\0\0\0\0\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\x93\x84\x16\x95Pc-y\xDBF\x94Pa\x06\x9E\x93a\x01\0\x90\x93\x04\x90\x92\x16\x91`(\x90\x87\x90`\x04\x01a-:V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05|W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x0E\x12\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0E>\x90a)\xE3V[\x80\x15a\x0E\x89W\x80`\x1F\x10a\x0E`Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0E\x89V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0ElW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x0F W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0E\xCDW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\r\xE2V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05|W\x83\x82\x90_R` _ \x01\x80Ta\x0Fx\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F\xA4\x90a)\xE3V[\x80\x15a\x0F\xEFW\x80`\x1F\x10a\x0F\xC6Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F\xEFV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\xD2W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0F[V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05|W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x10\xEEW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x10\x9BW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x10&V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05|W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x11\xF1W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x11\x9EW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x11)V[`%T`\x1FT`&T`@Q\x7F-y\xDBF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R_\x93s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16\x93c-y\xDBF\x93a\x12v\x93a\x01\0\x90\x92\x04\x90\x92\x16\x91\x90`(\x90`,\x90`\x04\x01a+\xECV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x12\x91W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xB5\x91\x90a,=V[\x90Pa\x12\xC3\x81`'Ta 7V[PV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05|W\x83\x82\x90_R` _ \x01\x80Ta\x13\x06\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x132\x90a)\xE3V[\x80\x15a\x13}W\x80`\x1F\x10a\x13TWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x13}V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x13`W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x12\xE9V[`\x08T_\x90`\xFF\x16\x15a\x13\xA8WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x146W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x14Z\x91\x90a,=V[\x14\x15\x90P\x90V[`@\x80Q`\x80\x81\x01\x90\x91R`(\x80T`\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\x82R`)\x80T_\x93\x92\x91` \x84\x01\x91a\x14\xAD\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x14\xD9\x90a)\xE3V[\x80\x15a\x15$W\x80`\x1F\x10a\x14\xFBWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x15$V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15\x07W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x02\x82\x01\x80Ta\x15=\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x15i\x90a)\xE3V[\x80\x15a\x15\xB4W\x80`\x1F\x10a\x15\x8BWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x15\xB4V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15\x97W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x83RPP`\x03\x91\x90\x91\x01T`\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` \x91\x82\x01R|\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``\x83\x81\x01\x91\x90\x91R`@\x80Q\x91\x82\x01\x90R`<\x80\x82R\x92\x93Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x92c\xF2\x8D\xCE\xB3\x92a/\xBA\x90\x83\x019`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\n\x1F\x91\x90a&\\V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x042W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x04\x07WPPPPP\x90P\x90V[_`,`@Q\x80`\xA0\x01`@R\x90\x81_\x82\x01\x80Ta\x16\xED\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x17\x19\x90a)\xE3V[\x80\x15a\x17dW\x80`\x1F\x10a\x17;Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x17dV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x17GW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01T\x81R` \x01`\x02\x82\x01\x80Ta\x17\x87\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x17\xB3\x90a)\xE3V[\x80\x15a\x17\xFEW\x80`\x1F\x10a\x17\xD5Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x17\xFEV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x17\xE1W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x03\x82\x01T\x81R` \x01`\x04\x82\x01\x80Ta\x18!\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x18M\x90a)\xE3V[\x80\x15a\x18\x98W\x80`\x1F\x10a\x18oWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x18\x98V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x18{W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPP`@\x80Q\x80\x82\x01\x82R`\x01\x81R_` \x80\x83\x01\x91\x90\x91R\x90\x84R\x81Q\x80\x83\x01\x83R`\x16\x81R\x7FBad merkle array proof\0\0\0\0\0\0\0\0\0\0\x91\x81\x01\x91\x90\x91R\x90Q\x7F\xF2\x8D\xCE\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\x92\x93Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x92c\xF2\x8D\xCE\xB3\x92Pa\r)\x91\x90`\x04\x01a&\\V[`@\x80Q`\x80\x81\x01\x90\x91R`(\x80T`\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\x82R`)\x80T_\x93\x92\x91` \x84\x01\x91a\x19\x8C\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x19\xB8\x90a)\xE3V[\x80\x15a\x1A\x03W\x80`\x1F\x10a\x19\xDAWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x1A\x03V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x19\xE6W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x02\x82\x01\x80Ta\x1A\x1C\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x1AH\x90a)\xE3V[\x80\x15a\x1A\x93W\x80`\x1F\x10a\x1AjWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x1A\x93V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x1AvW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x83RPP`\x03\x91\x90\x91\x01T`\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` \x91\x82\x01R`@\x80Q\x80\x82\x01\x82R`\x01\x81R_\x81\x84\x01R\x83\x83\x01R\x80Q\x80\x82\x01\x82R`\x1D\x81R\x7FInvalid input vector provided\0\0\0\x92\x81\x01\x92\x90\x92RQ\x7F\xF2\x8D\xCE\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\x91\x92Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\n\x1F\x91`\x04\x01a&\\V[`\x1FT`@Q\x7F\xF5\x8D\xB0o\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R_`\x04\x82\x01\x81\x90R`$\x82\x01Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90c\xF5\x8D\xB0o\x90`D\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1B\xD8W__\xFD[PZ\xF1\x15\x80\x15a\x1B\xEAW=__>=_\xFD[PP`@\x80Q\x80\x82\x01\x82R`\x1B\x81R\x7FGCD does not confirm header\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x93Pc\xF2\x8D\xCE\xB3\x92Pa\x1Co\x91\x90`\x04\x01a&\\V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1C\x86W__\xFD[PZ\xF1\x15\x80\x15a\x1C\x98W=__>=_\xFD[PP`%T`\x1FT`&T`@Q\x7F-y\xDBF\0\0\0\0\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\x93\x84\x16\x95Pc-y\xDBF\x94Pa\x1D\x06\x93a\x01\0\x90\x93\x04\x90\x92\x16\x91`(\x90`,\x90`\x04\x01a+\xECV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1D!W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xC3\x91\x90a,=V[``a\x03U\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa \xBAV[``a\x1D\x94\x84\x84a)xV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xACWa\x1D\xACa$\xBFV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x1D\xDFW\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x1D\xCAW\x90P[P\x90P\x83[\x83\x81\x10\x15a\x1E\xE0Wa\x1E\xB2\x86a\x1D\xF9\x83a\"\x08V[\x85`@Q` \x01a\x1E\x0C\x93\x92\x91\x90a-\xDDV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x1E(\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x1ET\x90a)\xE3V[\x80\x15a\x1E\x9FW\x80`\x1F\x10a\x1EvWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x1E\x9FV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x1E\x82W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa#9\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x1E\xBD\x87\x84a)xV[\x81Q\x81\x10a\x1E\xCDWa\x1E\xCDa)\x8BV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x1D\xE4V[P\x94\x93PPPPV[``a\x1E\xF5\x84\x84a)xV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\rWa\x1F\ra$\xBFV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x1F6W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x1E\xE0Wa \t\x86a\x1FP\x83a\"\x08V[\x85`@Q` \x01a\x1Fc\x93\x92\x91\x90a-\xDDV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x1F\x7F\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x1F\xAB\x90a)\xE3V[\x80\x15a\x1F\xF6W\x80`\x1F\x10a\x1F\xCDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x1F\xF6V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x1F\xD9W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa#\xD8\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a \x14\x87\x84a)xV[\x81Q\x81\x10a $Wa $a)\x8BV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x1F;V[`@Q\x7F|\x84\xC6\x9B\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c|\x84\xC6\x9B\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a \xA0W__\xFD[PZ\xFA\x15\x80\x15a \xB2W=__>=_\xFD[PPPPPPV[``a \xC6\x84\x84a)xV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a \xDEWa \xDEa$\xBFV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a!\x07W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x1E\xE0Wa!\xDA\x86a!!\x83a\"\x08V[\x85`@Q` \x01a!4\x93\x92\x91\x90a-\xDDV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta!P\x90a)\xE3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta!|\x90a)\xE3V[\x80\x15a!\xC7W\x80`\x1F\x10a!\x9EWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a!\xC7V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a!\xAAW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa$k\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a!\xE5\x87\x84a)xV[\x81Q\x81\x10a!\xF5Wa!\xF5a)\x8BV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a!\x0CV[``\x81_\x03a\"JWPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\"sW\x80a\"]\x81a.zV[\x91Pa\"l\x90P`\n\x83a.\xDEV[\x91Pa\"MV[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\"\x8DWa\"\x8Da$\xBFV[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\"\xB7W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x03UWa\"\xCC`\x01\x83a)xV[\x91Pa\"\xD9`\n\x86a.\xF1V[a\"\xE4\x90`0a/\x04V[`\xF8\x1B\x81\x83\x81Q\x81\x10a\"\xF9Wa\"\xF9a)\x8BV[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa#2`\n\x86a.\xDEV[\x94Pa\"\xBBV[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a#\x8E\x90\x86\x90\x86\x90`\x04\x01a/\x17V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a#\xA8W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra#\xCF\x91\x90\x81\x01\x90a/DV[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a$,\x90\x86\x90\x86\x90`\x04\x01a/\x17V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a$GW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a#\xCF\x91\x90a,=V[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a$,\x90\x86\x90\x86\x90`\x04\x01a/\x17V[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a%\x15Wa%\x15a$\xBFV[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a%6Wa%6a$\xBFV[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a%VW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a%lW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a%|W__\xFD[\x805a%\x8Fa%\x8A\x82a%\x1DV[a$\xECV[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a%\xA3W__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a&PW`?\x19\x87\x86\x03\x01\x84Ra&;\x85\x83Qa%\xCBV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a&\x1FV[P\x92\x96\x95PPPPPPV[` \x81R_a#\xCF` \x83\x01\x84a%\xCBV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a&\xBBW\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&\x87V[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a'\x14W`\x1F\x19\x85\x84\x03\x01\x88Ra&\xFE\x83\x83Qa%\xCBV[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a&\xE2V[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a&PW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra'\x8E`@\x87\x01\x82a&\xC6V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a'FV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a&\xBBW\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a'\xBDV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a(-W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a'\xEDV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a&PW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra(\x83`@\x88\x01\x82a%\xCBV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra(\x9E\x81\x83a'\xDBV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a(]V[` \x81R_a#\xCF` \x83\x01\x84a&\xC6V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a&PW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra)5`@\x87\x01\x82a'\xDBV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a(\xEDV[\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#\xD2Wa#\xD2a)KV[\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x03Ua)\xDD\x83\x86a)\xB8V[\x84a)\xB8V[`\x01\x81\x81\x1C\x90\x82\x16\x80a)\xF7W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a*.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`\"`\x04R`$_\xFD[P\x91\x90PV[\x80T_\x90`\x01\x81\x81\x1C\x90\x82\x16\x80a*LW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a*\x83W\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[\x81\x86R` \x86\x01\x81\x80\x15a*\x9EW`\x01\x81\x14a*\xD2Wa*\xFEV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x85\x16\x82R\x83\x15\x15`\x05\x1B\x82\x01\x95Pa*\xFEV[_\x87\x81R` \x90 _[\x85\x81\x10\x15a*\xF8W\x81T\x84\x82\x01R`\x01\x90\x91\x01\x90` \x01a*\xDCV[\x83\x01\x96PP[PPPPP\x92\x91PPV[\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\x81T`\xE0\x1B\x16\x82R`\x80` \x83\x01R_a+J`\x80\x84\x01`\x01\x84\x01a*4V[\x83\x81\x03`@\x85\x01Ra+_\x81`\x02\x85\x01a*4V[\x90P\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`\x03\x84\x01T`\xE0\x1B\x16``\x85\x01R\x80\x91PP\x92\x91PPV[`\xA0\x82R_a+\xAC`\xA0\x84\x01\x83a*4V[`\x01\x83\x01T` \x85\x01R\x83\x81\x03`@\x85\x01Ra+\xCB\x81`\x02\x85\x01a*4V[\x90P`\x03\x83\x01T``\x85\x01R\x83\x81\x03`\x80\x85\x01Ra\x03U\x81`\x04\x85\x01a*4V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x81R\x83` \x82\x01R`\x80`@\x82\x01R_a, `\x80\x83\x01\x85a+\tV[\x82\x81\x03``\x84\x01Ra,2\x81\x85a+\x9AV[\x97\x96PPPPPPPV[_` \x82\x84\x03\x12\x15a,MW__\xFD[PQ\x91\x90PV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x81R\x83` \x82\x01R`\x80`@\x82\x01R\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\x83Q\x16`\x80\x82\x01R_` \x84\x01Q`\x80`\xA0\x84\x01Ra,\xBEa\x01\0\x84\x01\x82a%\xCBV[\x90P`@\x85\x01Q\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x84\x83\x03\x01`\xC0\x85\x01Ra,\xF9\x82\x82a%\xCBV[\x91PP\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``\x86\x01Q\x16`\xE0\x84\x01R\x82\x81\x03``\x84\x01Ra,2\x81\x85a+\x9AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x81R\x83` \x82\x01R`\x80`@\x82\x01R_a-n`\x80\x83\x01\x85a+\tV[\x82\x81\x03``\x84\x01R\x83Q`\xA0\x82Ra-\x89`\xA0\x83\x01\x82a%\xCBV[\x90P` \x85\x01Q` \x83\x01R`@\x85\x01Q\x82\x82\x03`@\x84\x01Ra-\xAC\x82\x82a%\xCBV[\x91PP``\x85\x01Q``\x83\x01R`\x80\x85\x01Q\x82\x82\x03`\x80\x84\x01Ra-\xD0\x82\x82a%\xCBV[\x99\x98PPPPPPPPPV[\x7F.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R_a.\x0E`\x01\x83\x01\x86a)\xB8V[\x7F[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra.>`\x01\x82\x01\x86a)\xB8V[\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\x81Ra.p`\x02\x82\x01\x85a)\xB8V[\x96\x95PPPPPPV[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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.\xAAWa.\xAAa)KV[P`\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`\x12`\x04R`$_\xFD[_\x82a.\xECWa.\xECa.\xB1V[P\x04\x90V[_\x82a.\xFFWa.\xFFa.\xB1V[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a#\xD2Wa#\xD2a)KV[`@\x81R_a/)`@\x83\x01\x85a%\xCBV[\x82\x81\x03` \x84\x01Ra/;\x81\x85a%\xCBV[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a/TW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a/jW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a/zW__\xFD[\x80Qa/\x88a%\x8A\x82a%\x1DV[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a/\x9CW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV\xFETx merkle proof is not valid for provided header and tx hash\0\0\0 s\xBD!\x84\xED\xD9\xC4\xFCvd.\xA6uN\xE4\x016\x97\x0E\xFC\x10\xC4\x19\0\0\0\0\0\0\0\0\0\x02\x96\xEF\x12>\xA9m\xA5\xCFi_\"\xBF}\x94\xBE\x87\xD4\x9D\xB1\xADz\xC3q\xACC\xC4\xDAAa\xC8\xC2\x164\x9C[\xA1\x19(\x17\r8x\xA2dipfsX\"\x12 \xFD\xEF6P\xB6\x97\xA7\xD9\xFF\xBA\x1AV\xB5\x97\x15\xEF\x8F\xC9\xA3K\xAF\x19\xFB}\x99\xDEWQ\xFF\xCA\x90\x84dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. -```solidity -event log(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getBlockHeights(string,uint256,uint256)` and selector `0xfad06b8f`. -```solidity -function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getBlockHeightsCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getBlockHeights(string,uint256,uint256)`](getBlockHeightsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getBlockHeightsReturn { - #[allow(missing_docs)] - pub elements: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getBlockHeightsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - #[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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getBlockHeightsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getBlockHeightsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getBlockHeights(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [250u8, 208u8, 107u8, 143u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getDigestLes(string,uint256,uint256)` and selector `0x44badbb6`. -```solidity -function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getDigestLesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getDigestLes(string,uint256,uint256)`](getDigestLesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getDigestLesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getDigestLesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getDigestLesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getDigestLesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array< - alloy::sol_types::sol_data::FixedBytes<32>, - >, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getDigestLes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [68u8, 186u8, 219u8, 182u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaderHexes(string,uint256,uint256)` and selector `0x0813852a`. -```solidity -function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaderHexes(string,uint256,uint256)`](getHeaderHexesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeaderHexesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getHeaderHexesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getHeaderHexesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Bytes, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaderHexes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [8u8, 19u8, 133u8, 42u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaders(string,uint256,uint256)` and selector `0x1c0da81f`. -```solidity -function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaders(string,uint256,uint256)`](getHeadersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersReturn { - #[allow(missing_docs)] - pub headers: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersReturn) -> Self { - (value.headers,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { headers: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getHeadersCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Bytes; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaders(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [28u8, 13u8, 168u8, 31u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testGCDDoesntConfirmHeader()` and selector `0xf11d5cbc`. -```solidity -function testGCDDoesntConfirmHeader() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testGCDDoesntConfirmHeaderCall; - ///Container type for the return parameters of the [`testGCDDoesntConfirmHeader()`](testGCDDoesntConfirmHeaderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testGCDDoesntConfirmHeaderReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testGCDDoesntConfirmHeaderCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testGCDDoesntConfirmHeaderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testGCDDoesntConfirmHeaderReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testGCDDoesntConfirmHeaderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testGCDDoesntConfirmHeaderReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testGCDDoesntConfirmHeaderCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testGCDDoesntConfirmHeaderReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testGCDDoesntConfirmHeader()"; - const SELECTOR: [u8; 4] = [241u8, 29u8, 92u8, 188u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testGCDDoesntConfirmHeaderReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testIncorrectInputVectorSupplied()` and selector `0xef3e6812`. -```solidity -function testIncorrectInputVectorSupplied() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIncorrectInputVectorSuppliedCall; - ///Container type for the return parameters of the [`testIncorrectInputVectorSupplied()`](testIncorrectInputVectorSuppliedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIncorrectInputVectorSuppliedReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIncorrectInputVectorSuppliedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIncorrectInputVectorSuppliedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIncorrectInputVectorSuppliedReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIncorrectInputVectorSuppliedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testIncorrectInputVectorSuppliedReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testIncorrectInputVectorSuppliedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testIncorrectInputVectorSuppliedReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testIncorrectInputVectorSupplied()"; - const SELECTOR: [u8; 4] = [239u8, 62u8, 104u8, 18u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testIncorrectInputVectorSuppliedReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testIncorrectLocktimeSupplied()` and selector `0xc899d241`. -```solidity -function testIncorrectLocktimeSupplied() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIncorrectLocktimeSuppliedCall; - ///Container type for the return parameters of the [`testIncorrectLocktimeSupplied()`](testIncorrectLocktimeSuppliedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIncorrectLocktimeSuppliedReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIncorrectLocktimeSuppliedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIncorrectLocktimeSuppliedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIncorrectLocktimeSuppliedReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIncorrectLocktimeSuppliedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testIncorrectLocktimeSuppliedReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testIncorrectLocktimeSuppliedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testIncorrectLocktimeSuppliedReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testIncorrectLocktimeSupplied()"; - const SELECTOR: [u8; 4] = [200u8, 153u8, 210u8, 65u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testIncorrectLocktimeSuppliedReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testIncorrectOutputVectorSupplied()` and selector `0x5df0d076`. -```solidity -function testIncorrectOutputVectorSupplied() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIncorrectOutputVectorSuppliedCall; - ///Container type for the return parameters of the [`testIncorrectOutputVectorSupplied()`](testIncorrectOutputVectorSuppliedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIncorrectOutputVectorSuppliedReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIncorrectOutputVectorSuppliedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIncorrectOutputVectorSuppliedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIncorrectOutputVectorSuppliedReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIncorrectOutputVectorSuppliedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testIncorrectOutputVectorSuppliedReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testIncorrectOutputVectorSuppliedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testIncorrectOutputVectorSuppliedReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testIncorrectOutputVectorSupplied()"; - const SELECTOR: [u8; 4] = [93u8, 240u8, 208u8, 118u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testIncorrectOutputVectorSuppliedReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testIncorrectProofSupplied()` and selector `0xe89f8419`. -```solidity -function testIncorrectProofSupplied() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIncorrectProofSuppliedCall; - ///Container type for the return parameters of the [`testIncorrectProofSupplied()`](testIncorrectProofSuppliedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIncorrectProofSuppliedReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIncorrectProofSuppliedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIncorrectProofSuppliedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIncorrectProofSuppliedReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIncorrectProofSuppliedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testIncorrectProofSuppliedReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testIncorrectProofSuppliedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testIncorrectProofSuppliedReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testIncorrectProofSupplied()"; - const SELECTOR: [u8; 4] = [232u8, 159u8, 132u8, 25u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testIncorrectProofSuppliedReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testInsufficientConfirmations()` and selector `0x39425f8f`. -```solidity -function testInsufficientConfirmations() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testInsufficientConfirmationsCall; - ///Container type for the return parameters of the [`testInsufficientConfirmations()`](testInsufficientConfirmationsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testInsufficientConfirmationsReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testInsufficientConfirmationsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testInsufficientConfirmationsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testInsufficientConfirmationsReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testInsufficientConfirmationsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testInsufficientConfirmationsReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testInsufficientConfirmationsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testInsufficientConfirmationsReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testInsufficientConfirmations()"; - const SELECTOR: [u8; 4] = [57u8, 66u8, 95u8, 143u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testInsufficientConfirmationsReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testInvalidHeaderSupplied()` and selector `0x632ad534`. -```solidity -function testInvalidHeaderSupplied() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testInvalidHeaderSuppliedCall; - ///Container type for the return parameters of the [`testInvalidHeaderSupplied()`](testInvalidHeaderSuppliedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testInvalidHeaderSuppliedReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testInvalidHeaderSuppliedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testInvalidHeaderSuppliedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testInvalidHeaderSuppliedReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testInvalidHeaderSuppliedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testInvalidHeaderSuppliedReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testInvalidHeaderSuppliedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testInvalidHeaderSuppliedReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testInvalidHeaderSupplied()"; - const SELECTOR: [u8; 4] = [99u8, 42u8, 213u8, 52u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testInvalidHeaderSuppliedReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testInvalidMerkleProofSupplied()` and selector `0xed5a9c49`. -```solidity -function testInvalidMerkleProofSupplied() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testInvalidMerkleProofSuppliedCall; - ///Container type for the return parameters of the [`testInvalidMerkleProofSupplied()`](testInvalidMerkleProofSuppliedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testInvalidMerkleProofSuppliedReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testInvalidMerkleProofSuppliedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testInvalidMerkleProofSuppliedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testInvalidMerkleProofSuppliedReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testInvalidMerkleProofSuppliedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testInvalidMerkleProofSuppliedReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testInvalidMerkleProofSuppliedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testInvalidMerkleProofSuppliedReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testInvalidMerkleProofSupplied()"; - const SELECTOR: [u8; 4] = [237u8, 90u8, 156u8, 73u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testInvalidMerkleProofSuppliedReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testSuccessfullyVerify()` and selector `0xb52b2058`. -```solidity -function testSuccessfullyVerify() external view; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testSuccessfullyVerifyCall; - ///Container type for the return parameters of the [`testSuccessfullyVerify()`](testSuccessfullyVerifyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testSuccessfullyVerifyReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testSuccessfullyVerifyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testSuccessfullyVerifyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testSuccessfullyVerifyReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testSuccessfullyVerifyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testSuccessfullyVerifyReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testSuccessfullyVerifyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testSuccessfullyVerifyReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testSuccessfullyVerify()"; - const SELECTOR: [u8; 4] = [181u8, 43u8, 32u8, 88u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testSuccessfullyVerifyReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`FullRelayWithVerifyThroughBitcoinTxTest`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum FullRelayWithVerifyThroughBitcoinTxTestCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - getBlockHeights(getBlockHeightsCall), - #[allow(missing_docs)] - getDigestLes(getDigestLesCall), - #[allow(missing_docs)] - getHeaderHexes(getHeaderHexesCall), - #[allow(missing_docs)] - getHeaders(getHeadersCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - testGCDDoesntConfirmHeader(testGCDDoesntConfirmHeaderCall), - #[allow(missing_docs)] - testIncorrectInputVectorSupplied(testIncorrectInputVectorSuppliedCall), - #[allow(missing_docs)] - testIncorrectLocktimeSupplied(testIncorrectLocktimeSuppliedCall), - #[allow(missing_docs)] - testIncorrectOutputVectorSupplied(testIncorrectOutputVectorSuppliedCall), - #[allow(missing_docs)] - testIncorrectProofSupplied(testIncorrectProofSuppliedCall), - #[allow(missing_docs)] - testInsufficientConfirmations(testInsufficientConfirmationsCall), - #[allow(missing_docs)] - testInvalidHeaderSupplied(testInvalidHeaderSuppliedCall), - #[allow(missing_docs)] - testInvalidMerkleProofSupplied(testInvalidMerkleProofSuppliedCall), - #[allow(missing_docs)] - testSuccessfullyVerify(testSuccessfullyVerifyCall), - } - #[automatically_derived] - impl FullRelayWithVerifyThroughBitcoinTxTestCalls { - /// 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, 19u8, 133u8, 42u8], - [28u8, 13u8, 168u8, 31u8], - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [57u8, 66u8, 95u8, 143u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [68u8, 186u8, 219u8, 182u8], - [93u8, 240u8, 208u8, 118u8], - [99u8, 42u8, 213u8, 52u8], - [102u8, 217u8, 169u8, 160u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 43u8, 32u8, 88u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [200u8, 153u8, 210u8, 65u8], - [226u8, 12u8, 159u8, 113u8], - [232u8, 159u8, 132u8, 25u8], - [237u8, 90u8, 156u8, 73u8], - [239u8, 62u8, 104u8, 18u8], - [241u8, 29u8, 92u8, 188u8], - [250u8, 118u8, 38u8, 212u8], - [250u8, 208u8, 107u8, 143u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for FullRelayWithVerifyThroughBitcoinTxTestCalls { - const NAME: &'static str = "FullRelayWithVerifyThroughBitcoinTxTestCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 25usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::getBlockHeights(_) => { - ::SELECTOR - } - Self::getDigestLes(_) => { - ::SELECTOR - } - Self::getHeaderHexes(_) => { - ::SELECTOR - } - Self::getHeaders(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::testGCDDoesntConfirmHeader(_) => { - ::SELECTOR - } - Self::testIncorrectInputVectorSupplied(_) => { - ::SELECTOR - } - Self::testIncorrectLocktimeSupplied(_) => { - ::SELECTOR - } - Self::testIncorrectOutputVectorSupplied(_) => { - ::SELECTOR - } - Self::testIncorrectProofSupplied(_) => { - ::SELECTOR - } - Self::testInsufficientConfirmations(_) => { - ::SELECTOR - } - Self::testInvalidHeaderSupplied(_) => { - ::SELECTOR - } - Self::testInvalidMerkleProofSupplied(_) => { - ::SELECTOR - } - Self::testSuccessfullyVerify(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - >] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::getHeaderHexes, - ) - } - getHeaderHexes - }, - { - fn getHeaders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::getHeaders, - ) - } - getHeaders - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::excludeSenders, - ) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::targetInterfaces, - ) - } - targetInterfaces - }, - { - fn testInsufficientConfirmations( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::testInsufficientConfirmations, - ) - } - testInsufficientConfirmations - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::targetSenders, - ) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::targetContracts, - ) - } - targetContracts - }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::getDigestLes, - ) - } - getDigestLes - }, - { - fn testIncorrectOutputVectorSupplied( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::testIncorrectOutputVectorSupplied, - ) - } - testIncorrectOutputVectorSupplied - }, - { - fn testInvalidHeaderSupplied( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::testInvalidHeaderSupplied, - ) - } - testInvalidHeaderSupplied - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::targetArtifacts, - ) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::targetSelectors, - ) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::excludeSelectors, - ) - } - excludeSelectors - }, - { - fn testSuccessfullyVerify( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::testSuccessfullyVerify, - ) - } - testSuccessfullyVerify - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::excludeArtifacts, - ) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw(data) - .map(FullRelayWithVerifyThroughBitcoinTxTestCalls::failed) - } - failed - }, - { - fn testIncorrectLocktimeSupplied( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::testIncorrectLocktimeSupplied, - ) - } - testIncorrectLocktimeSupplied - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::excludeContracts, - ) - } - excludeContracts - }, - { - fn testIncorrectProofSupplied( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::testIncorrectProofSupplied, - ) - } - testIncorrectProofSupplied - }, - { - fn testInvalidMerkleProofSupplied( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::testInvalidMerkleProofSupplied, - ) - } - testInvalidMerkleProofSupplied - }, - { - fn testIncorrectInputVectorSupplied( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::testIncorrectInputVectorSupplied, - ) - } - testIncorrectInputVectorSupplied - }, - { - fn testGCDDoesntConfirmHeader( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::testGCDDoesntConfirmHeader, - ) - } - testGCDDoesntConfirmHeader - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw(data) - .map(FullRelayWithVerifyThroughBitcoinTxTestCalls::IS_TEST) - } - IS_TEST - }, - { - fn getBlockHeights( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::getBlockHeights, - ) - } - getBlockHeights - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - >] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::getHeaderHexes, - ) - } - getHeaderHexes - }, - { - fn getHeaders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::getHeaders, - ) - } - getHeaders - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::excludeSenders, - ) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::targetInterfaces, - ) - } - targetInterfaces - }, - { - fn testInsufficientConfirmations( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::testInsufficientConfirmations, - ) - } - testInsufficientConfirmations - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::targetSenders, - ) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::targetContracts, - ) - } - targetContracts - }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::getDigestLes, - ) - } - getDigestLes - }, - { - fn testIncorrectOutputVectorSupplied( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::testIncorrectOutputVectorSupplied, - ) - } - testIncorrectOutputVectorSupplied - }, - { - fn testInvalidHeaderSupplied( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::testInvalidHeaderSupplied, - ) - } - testInvalidHeaderSupplied - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::targetArtifacts, - ) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::targetSelectors, - ) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::excludeSelectors, - ) - } - excludeSelectors - }, - { - fn testSuccessfullyVerify( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::testSuccessfullyVerify, - ) - } - testSuccessfullyVerify - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::excludeArtifacts, - ) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayWithVerifyThroughBitcoinTxTestCalls::failed) - } - failed - }, - { - fn testIncorrectLocktimeSupplied( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::testIncorrectLocktimeSupplied, - ) - } - testIncorrectLocktimeSupplied - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::excludeContracts, - ) - } - excludeContracts - }, - { - fn testIncorrectProofSupplied( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::testIncorrectProofSupplied, - ) - } - testIncorrectProofSupplied - }, - { - fn testInvalidMerkleProofSupplied( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::testInvalidMerkleProofSupplied, - ) - } - testInvalidMerkleProofSupplied - }, - { - fn testIncorrectInputVectorSupplied( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::testIncorrectInputVectorSupplied, - ) - } - testIncorrectInputVectorSupplied - }, - { - fn testGCDDoesntConfirmHeader( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::testGCDDoesntConfirmHeader, - ) - } - testGCDDoesntConfirmHeader - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayWithVerifyThroughBitcoinTxTestCalls::IS_TEST) - } - IS_TEST - }, - { - fn getBlockHeights( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughBitcoinTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughBitcoinTxTestCalls::getBlockHeights, - ) - } - getBlockHeights - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::getBlockHeights(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getDigestLes(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getHeaders(inner) => { - ::abi_encoded_size(inner) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testGCDDoesntConfirmHeader(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testIncorrectInputVectorSupplied(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testIncorrectLocktimeSupplied(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testIncorrectOutputVectorSupplied(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testIncorrectProofSupplied(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testInsufficientConfirmations(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testInvalidHeaderSupplied(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testInvalidMerkleProofSupplied(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testSuccessfullyVerify(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::getBlockHeights(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getDigestLes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testGCDDoesntConfirmHeader(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testIncorrectInputVectorSupplied(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testIncorrectLocktimeSupplied(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testIncorrectOutputVectorSupplied(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testIncorrectProofSupplied(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testInsufficientConfirmations(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testInvalidHeaderSupplied(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testInvalidMerkleProofSupplied(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testSuccessfullyVerify(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`FullRelayWithVerifyThroughBitcoinTxTest`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum FullRelayWithVerifyThroughBitcoinTxTestEvents { - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl FullRelayWithVerifyThroughBitcoinTxTestEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface - for FullRelayWithVerifyThroughBitcoinTxTestEvents { - const NAME: &'static str = "FullRelayWithVerifyThroughBitcoinTxTestEvents"; - const COUNT: usize = 22usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 FullRelayWithVerifyThroughBitcoinTxTestEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`FullRelayWithVerifyThroughBitcoinTxTest`](self) contract instance. - -See the [wrapper's documentation](`FullRelayWithVerifyThroughBitcoinTxTestInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> FullRelayWithVerifyThroughBitcoinTxTestInstance { - FullRelayWithVerifyThroughBitcoinTxTestInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result< - FullRelayWithVerifyThroughBitcoinTxTestInstance, - >, - > { - FullRelayWithVerifyThroughBitcoinTxTestInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - FullRelayWithVerifyThroughBitcoinTxTestInstance::::deploy_builder(provider) - } - /**A [`FullRelayWithVerifyThroughBitcoinTxTest`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`FullRelayWithVerifyThroughBitcoinTxTest`](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 FullRelayWithVerifyThroughBitcoinTxTestInstance< - P, - N = alloy_contract::private::Ethereum, - > { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug - for FullRelayWithVerifyThroughBitcoinTxTestInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("FullRelayWithVerifyThroughBitcoinTxTestInstance") - .field(&self.address) - .finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayWithVerifyThroughBitcoinTxTestInstance { - /**Creates a new wrapper around an on-chain [`FullRelayWithVerifyThroughBitcoinTxTest`](self) contract instance. - -See the [wrapper's documentation](`FullRelayWithVerifyThroughBitcoinTxTestInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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< - FullRelayWithVerifyThroughBitcoinTxTestInstance, - > { - 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 { - 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, - > FullRelayWithVerifyThroughBitcoinTxTestInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider( - self, - ) -> FullRelayWithVerifyThroughBitcoinTxTestInstance { - FullRelayWithVerifyThroughBitcoinTxTestInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayWithVerifyThroughBitcoinTxTestInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`getBlockHeights`] function. - pub fn getBlockHeights( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getBlockHeightsCall, N> { - self.call_builder( - &getBlockHeightsCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getDigestLes`] function. - pub fn getDigestLes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getDigestLesCall, N> { - self.call_builder( - &getDigestLesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaderHexes`] function. - pub fn getHeaderHexes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeaderHexesCall, N> { - self.call_builder( - &getHeaderHexesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaders`] function. - pub fn getHeaders( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeadersCall, N> { - self.call_builder( - &getHeadersCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`testGCDDoesntConfirmHeader`] function. - pub fn testGCDDoesntConfirmHeader( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testGCDDoesntConfirmHeaderCall, N> { - self.call_builder(&testGCDDoesntConfirmHeaderCall) - } - ///Creates a new call builder for the [`testIncorrectInputVectorSupplied`] function. - pub fn testIncorrectInputVectorSupplied( - &self, - ) -> alloy_contract::SolCallBuilder< - &P, - testIncorrectInputVectorSuppliedCall, - N, - > { - self.call_builder(&testIncorrectInputVectorSuppliedCall) - } - ///Creates a new call builder for the [`testIncorrectLocktimeSupplied`] function. - pub fn testIncorrectLocktimeSupplied( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testIncorrectLocktimeSuppliedCall, N> { - self.call_builder(&testIncorrectLocktimeSuppliedCall) - } - ///Creates a new call builder for the [`testIncorrectOutputVectorSupplied`] function. - pub fn testIncorrectOutputVectorSupplied( - &self, - ) -> alloy_contract::SolCallBuilder< - &P, - testIncorrectOutputVectorSuppliedCall, - N, - > { - self.call_builder(&testIncorrectOutputVectorSuppliedCall) - } - ///Creates a new call builder for the [`testIncorrectProofSupplied`] function. - pub fn testIncorrectProofSupplied( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testIncorrectProofSuppliedCall, N> { - self.call_builder(&testIncorrectProofSuppliedCall) - } - ///Creates a new call builder for the [`testInsufficientConfirmations`] function. - pub fn testInsufficientConfirmations( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testInsufficientConfirmationsCall, N> { - self.call_builder(&testInsufficientConfirmationsCall) - } - ///Creates a new call builder for the [`testInvalidHeaderSupplied`] function. - pub fn testInvalidHeaderSupplied( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testInvalidHeaderSuppliedCall, N> { - self.call_builder(&testInvalidHeaderSuppliedCall) - } - ///Creates a new call builder for the [`testInvalidMerkleProofSupplied`] function. - pub fn testInvalidMerkleProofSupplied( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testInvalidMerkleProofSuppliedCall, N> { - self.call_builder(&testInvalidMerkleProofSuppliedCall) - } - ///Creates a new call builder for the [`testSuccessfullyVerify`] function. - pub fn testSuccessfullyVerify( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testSuccessfullyVerifyCall, N> { - self.call_builder(&testSuccessfullyVerifyCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayWithVerifyThroughBitcoinTxTestInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/fullrelaywithverifythroughwitnesstxtest.rs b/crates/bindings/src/fullrelaywithverifythroughwitnesstxtest.rs deleted file mode 100644 index 908274fe3..000000000 --- a/crates/bindings/src/fullrelaywithverifythroughwitnesstxtest.rs +++ /dev/null @@ -1,9602 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface FullRelayWithVerifyThroughWitnessTxTest { - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); - function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); - function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); - function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function testGCDDoesntConfirmHeader() external; - function testInconsistentProofLengths() external; - function testIncorrectCoinbaseProofSupplied() external; - function testIncorrectPaymentProofSupplied() external; - function testInsufficientConfirmations() external; - function testSuccessfullyVerify() external view; -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getBlockHeights", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getDigestLes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes32[]", - "internalType": "bytes32[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaderHexes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes[]", - "internalType": "bytes[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaders", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "headers", - "type": "bytes", - "internalType": "bytes" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testGCDDoesntConfirmHeader", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testInconsistentProofLengths", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testIncorrectCoinbaseProofSupplied", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testIncorrectPaymentProofSupplied", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testInsufficientConfirmations", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testSuccessfullyVerify", - "inputs": [], - "outputs": [], - "stateMutability": "view" - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 FullRelayWithVerifyThroughWitnessTxTest { - use super::*; - use alloy::sol_types as 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"`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90Ua\x01\0`@R`P`\x80\x81\x81R\x90a\x7F\x83`\xA09`!\x90a\0=\x90\x82a\npV[P`@Q\x80a\x01`\x01`@R\x80a\x01@\x81R` \x01a\x814a\x01@\x919`\"\x90a\0g\x90\x82a\npV[P\x7FH\xE5\xA1\xA0\xE6\x16\xD8\xFD\x92\xB4\xEF\"\x8CBN\x0C\x81g\x99\xA2V\xC6\xA9\x08\x92\x19\\\xCF\xC53\0\xD6`#Ua\x01\x19`$U`@Qa\0\x9E\x90a\t\xBEV[`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\0\xB7W=__>=_\xFD[P`%\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90U`\x01`&U`@\x80Q`\xC0\x81\x01\x82R`\x01`\xF8\x1B\x81\x83\x01\x90\x81R\x82Q``\x80\x82\x01\x90\x94R`*\x80\x82R\x92\x93\x84\x93\x90\x84\x01\x91\x90a\x82\xDF` \x83\x019\x81R` \x01`@Q\x80`\x80\x01`@R\x80`K\x81R` \x01a\x80\xE9`K\x919\x81R` \x01_`\x01`\x01`\xE0\x1B\x03\x19\x16\x81RP\x81R` \x01`@Q\x80`\xA0\x01`@R\x80`k\x81R` \x01a\x82t`k\x919\x90R\x80Q\x80Q`'\x80Tc\xFF\xFF\xFF\xFF\x19\x16`\xE0\x92\x90\x92\x1C\x91\x90\x91\x17\x81U` \x82\x01Q\x90\x91\x90\x82\x90`(\x90a\x01\x95\x90\x82a\npV[P`@\x82\x01Q`\x02\x82\x01\x90a\x01\xAA\x90\x82a\npV[P``\x91\x90\x91\x01Q`\x03\x90\x91\x01\x80Tc\xFF\xFF\xFF\xFF\x19\x16`\xE0\x92\x90\x92\x1C\x91\x90\x91\x17\x90U` \x82\x01Q`\x04\x82\x01\x90a\x01\xE0\x90\x82a\npV[PP\x7Fr\xDA\xB3\x08\x07\x83\xB1\xB2\x9Dm\xE67$\x98\x7F\x9C\xE0\xC1\x98\x0C\xD1\xA5\x01\xF6\x8C\x192\"\x15\x80\xD1\x07`,UP`@\x80Q`\x80\x81\x01\x82R_\x81R\x7F\x9F\xA4[\xC4\xB84W\xFD\xAC\x0B\xE5/\t\x9E\xF0\xFD\xE5\x05\x0E\xEE\xBA\x14^\x1B\xF2\xDF\xE1\xD8<\x9E\xB6\x15` \x82\x01R\x81Qa\x02\0\x81\x01\x83Ra\x01@`\xA0\x82\x01\x81\x81R\x92\x93\x84\x01\x92\x82\x91a\x84I`\xC0\x84\x019\x81R` \x01a\x01\x19\x81R` \x01`!\x80Ta\x02v\x90a\t\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\xA2\x90a\t\xECV[\x80\x15a\x02\xEDW\x80`\x1F\x10a\x02\xC4Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02\xEDV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02\xD0W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01_\x81R` \x01`@Q\x80a\x01`\x01`@R\x80a\x01@\x81R` \x01a\x83\ta\x01@\x919\x81RP\x81R` \x01`@Q\x80`\x80\x01`@R\x80`\x01`\xF9\x1B`\x01`\x01`\xE0\x1B\x03\x19\x16\x81R` \x01`@Q\x80`\xA0\x01`@R\x80`u\x81R` \x01a\x80t`u\x919\x81R` \x01`@Q\x80`\xC0\x01`@R\x80`\x81\x81R` \x01a\x7F\xF3`\x81\x919\x81R_` \x91\x82\x01R\x91R\x81Q`-\x90\x81U\x90\x82\x01Q`.U`@\x82\x01Q\x80Q`/\x90\x81\x90a\x03\xA6\x90\x82a\npV[P` \x82\x01Q`\x01\x82\x01U`@\x82\x01Q`\x02\x82\x01\x90a\x03\xC5\x90\x82a\npV[P``\x82\x01Q`\x03\x82\x01U`\x80\x82\x01Q`\x04\x82\x01\x90a\x03\xE4\x90\x82a\npV[PPP``\x82\x01Q\x80Q`\x07\x83\x01\x80Tc\xFF\xFF\xFF\xFF\x19\x16`\xE0\x92\x90\x92\x1C\x91\x90\x91\x17\x81U` \x82\x01Q`\x08\x84\x01\x90a\x04\x1B\x90\x82a\npV[P`@\x82\x01Q`\x02\x82\x01\x90a\x040\x90\x82a\npV[P``\x82\x01Q\x81`\x03\x01_a\x01\0\n\x81T\x81c\xFF\xFF\xFF\xFF\x02\x19\x16\x90\x83`\xE0\x1C\x02\x17\x90UPPPPP4\x80\x15a\x04cW__\xFD[P`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k42\xB0\xB22\xB99\x9759\xB7\xB7`\xA1\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k\x05\xCC\xEC\xAD\xCC\xAEm.e\xCD\x0C\xAF`\xA3\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x0F\x81R` \x01n\x0B\x99\xD9[\x99\\\xDA\\\xCB\x9A\x19ZY\xDA\x1D`\x8A\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01q.genesis.digest_le`p\x1B\x81RP__Q` a\x7F\xD3_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x16c\xD90\xA0\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05JW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x05q\x91\x90\x81\x01\x90a\x0B\x9FV[\x90P_\x81\x86`@Q` \x01a\x05\x87\x92\x91\x90a\x0C\x02V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Rc`\xF9\xBB\x11`\xE0\x1B\x82R\x91P_Q` a\x7F\xD3_9_Q\x90_R\x90c`\xF9\xBB\x11\x90a\x05\xC7\x90\x84\x90`\x04\x01a\x0CtV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xE1W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x06\x08\x91\x90\x81\x01\x90a\x0B\x9FV[` \x90a\x06\x15\x90\x82a\npV[Pa\x06\xAC\x85` \x80Ta\x06'\x90a\t\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06S\x90a\t\xECV[\x80\x15a\x06\x9EW\x80`\x1F\x10a\x06uWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x06\x9EV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x06\x81W\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x08\x9A\x91PPV[a\x07B\x85` \x80Ta\x06\xBD\x90a\t\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06\xE9\x90a\t\xECV[\x80\x15a\x074W\x80`\x1F\x10a\x07\x0BWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x074V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\x17W\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\t\x17\x91PPV[a\x07\xD8\x85` \x80Ta\x07S\x90a\t\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07\x7F\x90a\t\xECV[\x80\x15a\x07\xCAW\x80`\x1F\x10a\x07\xA1Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07\xCAV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\xADW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\t\x8A\x91PPV[`@Qa\x07\xE4\x90a\t\xCBV[a\x07\xF0\x93\x92\x91\x90a\x0C\x86V[`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x08\tW=__>=_\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16a\x01\0`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x81\x02\x91\x90\x91\x17\x91\x82\x90U`@Qc\xF5\x8D\xB0o`\xE0\x1B\x81R`\x01`\x04\x82\x01\x81\x90R`$\x82\x01R\x91\x04\x90\x91\x16\x96Pc\xF5\x8D\xB0o\x95P`D\x01\x93Pa\x08h\x92PPPV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\x7FW__\xFD[PZ\xF1\x15\x80\x15a\x08\x91W=__>=_\xFD[PPPPa\x0C\xE5V[`@Qc\x1F\xB2C}`\xE3\x1B\x81R``\x90_Q` a\x7F\xD3_9_Q\x90_R\x90c\xFD\x92\x1B\xE8\x90a\x08\xCF\x90\x86\x90\x86\x90`\x04\x01a\x0C\xAAV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\xE9W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\t\x10\x91\x90\x81\x01\x90a\x0B\x9FV[\x93\x92PPPV[`@QcV\xEE\xF1[`\xE1\x1B\x81R_\x90_Q` a\x7F\xD3_9_Q\x90_R\x90c\xAD\xDD\xE2\xB6\x90a\tK\x90\x86\x90\x86\x90`\x04\x01a\x0C\xAAV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\tfW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\x10\x91\x90a\x0C\xCEV[`@Qc\x17w\xE5\x9D`\xE0\x1B\x81R_\x90_Q` a\x7F\xD3_9_Q\x90_R\x90c\x17w\xE5\x9D\x90a\tK\x90\x86\x90\x86\x90`\x04\x01a\x0C\xAAV[a\x15\xEC\x80a@\\\x839\x01\x90V[a);\x80aVH\x839\x01\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`\x01\x81\x81\x1C\x90\x82\x16\x80a\n\0W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\n\x1EWcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\nkW\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\nIWP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\nhW_\x81U`\x01\x01a\nUV[PP[PPPV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\n\x89Wa\n\x89a\t\xD8V[a\n\x9D\x81a\n\x97\x84Ta\t\xECV[\x84a\n$V[` `\x1F\x82\x11`\x01\x81\x14a\n\xCFW_\x83\x15a\n\xB8WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\nhV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\n\xFEW\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\n\xDEV[P\x84\x82\x10\x15a\x0B\x1BW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[_\x80`\x01`\x01`@\x1B\x03\x84\x11\x15a\x0BCWa\x0BCa\t\xD8V[P`@Q`\x1F\x19`\x1F\x85\x01\x81\x16`?\x01\x16\x81\x01\x81\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17\x15a\x0BqWa\x0Bqa\t\xD8V[`@R\x83\x81R\x90P\x80\x82\x84\x01\x85\x10\x15a\x0B\x88W__\xFD[\x83\x83` \x83\x01^_` \x85\x83\x01\x01RP\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x0B\xAFW__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x0B\xC4W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x0B\xD4W__\xFD[a\x0B\xE3\x84\x82Q` \x84\x01a\x0B*V[\x94\x93PPPPV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x0C\r\x82\x85a\x0B\xEBV[\x7F/test/fullRelay/testData/\0\0\0\0\0\0\0\x81Ra\x0C=`\x19\x82\x01\x85a\x0B\xEBV[\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R_a\t\x10` \x83\x01\x84a\x0CFV[``\x81R_a\x0C\x98``\x83\x01\x86a\x0CFV[` \x83\x01\x94\x90\x94RP`@\x01R\x91\x90PV[`@\x81R_a\x0C\xBC`@\x83\x01\x85a\x0CFV[\x82\x81\x03` \x84\x01Ra\x0C=\x81\x85a\x0CFV[_` \x82\x84\x03\x12\x15a\x0C\xDEW__\xFD[PQ\x91\x90PV[a3j\x80a\x0C\xF2_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01yW_5`\xE0\x1C\x80c\x85\"l\x81\x11a\0\xD2W\x80c\xB5P\x8A\xA9\x11a\0\x88W\x80c\xF1\x1D\\\xBC\x11a\0cW\x80c\xF1\x1D\\\xBC\x14a\x02\xB9W\x80c\xFAv&\xD4\x14a\x02\xC1W\x80c\xFA\xD0k\x8F\x14a\x02\xCEW__\xFD[\x80c\xB5P\x8A\xA9\x14a\x02\x91W\x80c\xBAAO\xA6\x14a\x02\x99W\x80c\xE2\x0C\x9Fq\x14a\x02\xB1W__\xFD[\x80c\x979\x0E\xD6\x11a\0\xB8W\x80c\x979\x0E\xD6\x14a\x02yW\x80c\xB0FO\xDC\x14a\x02\x81W\x80c\xB5+ X\x14a\x02\x89W__\xFD[\x80c\x85\"l\x81\x14a\x02OW\x80c\x91j\x17\xC6\x14a\x02dW__\xFD[\x80c>^<#\x11a\x012W\x80cf\xD9\xA9\xA0\x11a\x01\rW\x80cf\xD9\xA9\xA0\x14a\x02*W\x80cr\xE1\x11\xD2\x14a\x02?W\x80c\x80Q\xAC_\x14a\x02GW__\xFD[\x80c>^<#\x14a\x01\xFAW\x80c?r\x86\xF4\x14a\x02\x02W\x80cD\xBA\xDB\xB6\x14a\x02\nW__\xFD[\x80c\x1E\xD7\x83\x1C\x11a\x01bW\x80c\x1E\xD7\x83\x1C\x14a\x01\xC6W\x80c*\xDE8\x80\x14a\x01\xDBW\x80c9B_\x8F\x14a\x01\xF0W__\xFD[\x80c\x08\x13\x85*\x14a\x01}W\x80c\x1C\r\xA8\x1F\x14a\x01\xA6W[__\xFD[a\x01\x90a\x01\x8B6`\x04a%EV[a\x02\xE1V[`@Qa\x01\x9D\x91\x90a%\xFAV[`@Q\x80\x91\x03\x90\xF3[a\x01\xB9a\x01\xB46`\x04a%EV[a\x03,V[`@Qa\x01\x9D\x91\x90a&]V[a\x01\xCEa\x03\x9EV[`@Qa\x01\x9D\x91\x90a&oV[a\x01\xE3a\x04\x0BV[`@Qa\x01\x9D\x91\x90a'!V[a\x01\xF8a\x05TV[\0[a\x01\xCEa\x06\xB0V[a\x01\xCEa\x07\x1BV[a\x02\x1Da\x02\x186`\x04a%EV[a\x07\x86V[`@Qa\x01\x9D\x91\x90a'\xA5V[a\x022a\x07\xC9V[`@Qa\x01\x9D\x91\x90a(8V[a\x01\xF8a\tBV[a\x01\xF8a\r\xEBV[a\x02Wa\x11\xE5V[`@Qa\x01\x9D\x91\x90a(\xB6V[a\x02la\x12\xB0V[`@Qa\x01\x9D\x91\x90a(\xC8V[a\x01\xF8a\x13\xB3V[a\x02la\x17\xA0V[a\x01\xF8a\x18\xA3V[a\x02Wa\x19`V[a\x02\xA1a\x1A+V[`@Q\x90\x15\x15\x81R` \x01a\x01\x9DV[a\x01\xCEa\x1A\xFBV[a\x01\xF8a\x1BfV[`\x1FTa\x02\xA1\x90`\xFF\x16\x81V[a\x02\x1Da\x02\xDC6`\x04a%EV[a\x1DFV[``a\x03$\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1D\x89V[\x94\x93PPPPV[``_a\x03:\x85\x85\x85a\x02\xE1V[\x90P_[a\x03H\x85\x85a)yV[\x81\x10\x15a\x03\x95W\x82\x82\x82\x81Q\x81\x10a\x03bWa\x03ba)\x8CV[` \x02` \x01\x01Q`@Q` \x01a\x03{\x92\x91\x90a)\xD0V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x03>V[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x01W` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xD6W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x054W\x83\x82\x90_R` _ \x01\x80Ta\x04\xA9\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x04\xD5\x90a)\xE4V[\x80\x15a\x05 W\x80`\x1F\x10a\x04\xF7Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05 V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05\x03W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x04\x8CV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x04.V[PPPP\x90P\x90V[`@\x80Q\x80\x82\x01\x82R`\x1A\x81R\x7FInsufficient confirmations\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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`\t\x91sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x05\xD7\x91`\x04\x01a&]V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05\xEEW__\xFD[PZ\xF1\x15\x80\x15a\x06\0W=__>=_\xFD[PP`%T`\x1FT`@Q\x7F\x97B>\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16\x94Pc\x97B>\xB4\x93Pa\x06m\x92a\x01\0\x90\x92\x04\x90\x91\x16\x90\x85\x90`'\x90`-\x90`\x04\x01a+\xC2V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\x88W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xAC\x91\x90a,\x97V[PPV[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x01W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xD6WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x01W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xD6WPPPPP\x90P\x90V[``a\x03$\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1E\xEAV[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x08\x1C\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x08H\x90a)\xE4V[\x80\x15a\x08\x93W\x80`\x1F\x10a\x08jWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x08\x93V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x08vW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\t*W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x08\xD7W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07\xECV[`@\x80Q`\x80\x81\x01\x82R`-\x80T\x82R`.T` \x83\x01R\x82Q`\xA0\x81\x01\x84R`/\x80T_\x95\x85\x01\x92\x91\x90\x82\x90\x82\x90a\tz\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\t\xA6\x90a)\xE4V[\x80\x15a\t\xF1W\x80`\x1F\x10a\t\xC8Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\t\xF1V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t\xD4W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01T\x81R` \x01`\x02\x82\x01\x80Ta\n\x14\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n@\x90a)\xE4V[\x80\x15a\n\x8BW\x80`\x1F\x10a\nbWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\x8BV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\nnW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x03\x82\x01T\x81R` \x01`\x04\x82\x01\x80Ta\n\xAE\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n\xDA\x90a)\xE4V[\x80\x15a\x0B%W\x80`\x1F\x10a\n\xFCWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B%V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\x08W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP\x81R`@\x80Q`\x80\x81\x01\x90\x91R`\x07\x83\x01\x80T`\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\x82R`\x08\x84\x01\x80T` \x94\x85\x01\x94\x84\x01\x91\x90a\x0B\x82\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\xAE\x90a)\xE4V[\x80\x15a\x0B\xF9W\x80`\x1F\x10a\x0B\xD0Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\xF9V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xDCW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x02\x82\x01\x80Ta\x0C\x12\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C>\x90a)\xE4V[\x80\x15a\x0C\x89W\x80`\x1F\x10a\x0C`Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C\x89V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0ClW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x83RPP`\x03\x91\x90\x91\x01T`\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` \x91\x82\x01R\x91R`@\x80Qa\x01`\x81\x01\x90\x91Ra\x01@\x80\x82R\x93\x94P\x92\x91Pa0G\x90\x83\x019\x81`@\x01Q`\x80\x01\x81\x90RPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xF2\x8D\xCE\xB3`@Q\x80``\x01`@R\x80`?\x81R` \x01a2\xF6`?\x919`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\rU\x91\x90a&]V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\rlW__\xFD[PZ\xF1\x15\x80\x15a\r~W=__>=_\xFD[PP`%T`\x1FT`&T`@Q\x7F\x97B>\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x93\x84\x16\x95Pc\x97B>\xB4\x94Pa\x06m\x93a\x01\0\x90\x93\x04\x90\x92\x16\x91`'\x90\x87\x90`\x04\x01a-@V[`@\x80Q`\x80\x81\x01\x82R`-\x80T\x82R`.T` \x83\x01R\x82Q`\xA0\x81\x01\x84R`/\x80T_\x95\x85\x01\x92\x91\x90\x82\x90\x82\x90a\x0E#\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0EO\x90a)\xE4V[\x80\x15a\x0E\x9AW\x80`\x1F\x10a\x0EqWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0E\x9AV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0E}W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01T\x81R` \x01`\x02\x82\x01\x80Ta\x0E\xBD\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0E\xE9\x90a)\xE4V[\x80\x15a\x0F4W\x80`\x1F\x10a\x0F\x0BWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F4V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\x17W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x03\x82\x01T\x81R` \x01`\x04\x82\x01\x80Ta\x0FW\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F\x83\x90a)\xE4V[\x80\x15a\x0F\xCEW\x80`\x1F\x10a\x0F\xA5Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F\xCEV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\xB1W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP\x81R`@\x80Q`\x80\x81\x01\x90\x91R`\x07\x83\x01\x80T`\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\x82R`\x08\x84\x01\x80T` \x94\x85\x01\x94\x84\x01\x91\x90a\x10+\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x10W\x90a)\xE4V[\x80\x15a\x10\xA2W\x80`\x1F\x10a\x10yWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x10\xA2V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x10\x85W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x02\x82\x01\x80Ta\x10\xBB\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x10\xE7\x90a)\xE4V[\x80\x15a\x112W\x80`\x1F\x10a\x11\tWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x112V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x11\x15W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x83RPP`\x03\x91\x90\x91\x01T`\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` \x91\x82\x01R\x91R`@\x80Qa\x01`\x81\x01\x90\x91Ra\x01@\x80\x82R\x93\x94P\x92\x91Pa1\x87\x90\x83\x019`@\x80\x83\x01Q\x91\x90\x91R\x80Q`\x80\x81\x01\x90\x91R`D\x80\x82Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a0\x03` \x83\x019`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\rU\x91\x90a&]V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW\x83\x82\x90_R` _ \x01\x80Ta\x12%\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x12Q\x90a)\xE4V[\x80\x15a\x12\x9CW\x80`\x1F\x10a\x12sWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x12\x9CV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x12\x7FW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x12\x08V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x13\x9BW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x13HW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x12\xD3V[`@\x80Q`\x80\x81\x01\x82R`-\x80T\x82R`.T` \x83\x01R\x82Q`\xA0\x81\x01\x84R`/\x80T_\x95\x85\x01\x92\x91\x90\x82\x90\x82\x90a\x13\xEB\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x14\x17\x90a)\xE4V[\x80\x15a\x14bW\x80`\x1F\x10a\x149Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x14bV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x14EW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01T\x81R` \x01`\x02\x82\x01\x80Ta\x14\x85\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x14\xB1\x90a)\xE4V[\x80\x15a\x14\xFCW\x80`\x1F\x10a\x14\xD3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x14\xFCV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x14\xDFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x03\x82\x01T\x81R` \x01`\x04\x82\x01\x80Ta\x15\x1F\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x15K\x90a)\xE4V[\x80\x15a\x15\x96W\x80`\x1F\x10a\x15mWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x15\x96V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15yW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP\x81R`@\x80Q`\x80\x81\x01\x90\x91R`\x07\x83\x01\x80T`\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\x82R`\x08\x84\x01\x80T` \x94\x85\x01\x94\x84\x01\x91\x90a\x15\xF3\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x16\x1F\x90a)\xE4V[\x80\x15a\x16jW\x80`\x1F\x10a\x16AWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x16jV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x16MW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x02\x82\x01\x80Ta\x16\x83\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x16\xAF\x90a)\xE4V[\x80\x15a\x16\xFAW\x80`\x1F\x10a\x16\xD1Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x16\xFAV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x16\xDDW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x83RPP`\x03\x91\x90\x91\x01T`\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` \x91\x82\x01R\x91R`@\x80Q\x80\x82\x01\x82R`\x01\x81R_\x81\x84\x01R\x84\x82\x01QR\x80Q``\x81\x01\x90\x91R`/\x80\x82R\x93\x94Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x93c\xF2\x8D\xCE\xB3\x93P\x90\x91a2\xC7\x90\x83\x019`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\rU\x91\x90a&]V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x18\x8BW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x188W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x17\xC3V[`%T`\x1FT`&T`@Q\x7F\x97B>\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_\x93s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16\x93c\x97B>\xB4\x93a\x19\x10\x93a\x01\0\x90\x92\x04\x90\x92\x16\x91\x90`'\x90`-\x90`\x04\x01a+\xC2V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x19+W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x19O\x91\x90a,\x97V[\x90Pa\x19]\x81`,Ta 8V[PV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW\x83\x82\x90_R` _ \x01\x80Ta\x19\xA0\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x19\xCC\x90a)\xE4V[\x80\x15a\x1A\x17W\x80`\x1F\x10a\x19\xEEWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x1A\x17V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x19\xFAW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x19\x83V[`\x08T_\x90`\xFF\x16\x15a\x1ABWP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1A\xD0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1A\xF4\x91\x90a,\x97V[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x01W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xD6WPPPPP\x90P\x90V[`\x1FT`@Q\x7F\xF5\x8D\xB0o\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R_`\x04\x82\x01\x81\x90R`$\x82\x01Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90c\xF5\x8D\xB0o\x90`D\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1B\xD9W__\xFD[PZ\xF1\x15\x80\x15a\x1B\xEBW=__>=_\xFD[PP`@\x80Q\x80\x82\x01\x82R`\x1B\x81R\x7FGCD does not confirm header\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x93Pc\xF2\x8D\xCE\xB3\x92Pa\x1Cp\x91\x90`\x04\x01a&]V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1C\x87W__\xFD[PZ\xF1\x15\x80\x15a\x1C\x99W=__>=_\xFD[PP`%T`\x1FT`&T`@Q\x7F\x97B>\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x93\x84\x16\x95Pc\x97B>\xB4\x94Pa\x1D\x07\x93a\x01\0\x90\x93\x04\x90\x92\x16\x91`'\x90`-\x90`\x04\x01a+\xC2V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1D\"W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x19]\x91\x90a,\x97V[``a\x03$\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa \xBBV[``a\x1D\x95\x84\x84a)yV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xADWa\x1D\xADa$\xC0V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x1D\xE0W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x1D\xCBW\x90P[P\x90P\x83[\x83\x81\x10\x15a\x1E\xE1Wa\x1E\xB3\x86a\x1D\xFA\x83a\"\tV[\x85`@Q` \x01a\x1E\r\x93\x92\x91\x90a.&V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x1E)\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x1EU\x90a)\xE4V[\x80\x15a\x1E\xA0W\x80`\x1F\x10a\x1EwWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x1E\xA0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x1E\x83W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa#:\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x1E\xBE\x87\x84a)yV[\x81Q\x81\x10a\x1E\xCEWa\x1E\xCEa)\x8CV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x1D\xE5V[P\x94\x93PPPPV[``a\x1E\xF6\x84\x84a)yV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x0EWa\x1F\x0Ea$\xC0V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x1F7W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x1E\xE1Wa \n\x86a\x1FQ\x83a\"\tV[\x85`@Q` \x01a\x1Fd\x93\x92\x91\x90a.&V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x1F\x80\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x1F\xAC\x90a)\xE4V[\x80\x15a\x1F\xF7W\x80`\x1F\x10a\x1F\xCEWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x1F\xF7V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x1F\xDAW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa#\xD9\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a \x15\x87\x84a)yV[\x81Q\x81\x10a %Wa %a)\x8CV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x1F=_\xFD[PPPPPPV[``a \xC7\x84\x84a)yV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a \xDFWa \xDFa$\xC0V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a!\x08W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x1E\xE1Wa!\xDB\x86a!\"\x83a\"\tV[\x85`@Q` \x01a!5\x93\x92\x91\x90a.&V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta!Q\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta!}\x90a)\xE4V[\x80\x15a!\xC8W\x80`\x1F\x10a!\x9FWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a!\xC8V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a!\xABW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa$l\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a!\xE6\x87\x84a)yV[\x81Q\x81\x10a!\xF6Wa!\xF6a)\x8CV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a!\rV[``\x81_\x03a\"KWPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\"tW\x80a\"^\x81a.\xC3V[\x91Pa\"m\x90P`\n\x83a/'V[\x91Pa\"NV[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\"\x8EWa\"\x8Ea$\xC0V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\"\xB8W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x03$Wa\"\xCD`\x01\x83a)yV[\x91Pa\"\xDA`\n\x86a/:V[a\"\xE5\x90`0a/MV[`\xF8\x1B\x81\x83\x81Q\x81\x10a\"\xFAWa\"\xFAa)\x8CV[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa#3`\n\x86a/'V[\x94Pa\"\xBCV[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a#\x8F\x90\x86\x90\x86\x90`\x04\x01a/`V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a#\xA9W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra#\xD0\x91\x90\x81\x01\x90a/\x8DV[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a$-\x90\x86\x90\x86\x90`\x04\x01a/`V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a$HW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a#\xD0\x91\x90a,\x97V[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a$-\x90\x86\x90\x86\x90`\x04\x01a/`V[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a%\x16Wa%\x16a$\xC0V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a%7Wa%7a$\xC0V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a%WW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a%mW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a%}W__\xFD[\x805a%\x90a%\x8B\x82a%\x1EV[a$\xEDV[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a%\xA4W__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a&QW`?\x19\x87\x86\x03\x01\x84Ra&<\x85\x83Qa%\xCCV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a& V[P\x92\x96\x95PPPPPPV[` \x81R_a#\xD0` \x83\x01\x84a%\xCCV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a&\xBCW\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&\x88V[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a'\x15W`\x1F\x19\x85\x84\x03\x01\x88Ra&\xFF\x83\x83Qa%\xCCV[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a&\xE3V[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a&QW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra'\x8F`@\x87\x01\x82a&\xC7V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a'GV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a&\xBCW\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a'\xBEV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a(.W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a'\xEEV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a&QW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra(\x84`@\x88\x01\x82a%\xCCV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra(\x9F\x81\x83a'\xDCV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a(^V[` \x81R_a#\xD0` \x83\x01\x84a&\xC7V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a&QW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra)6`@\x87\x01\x82a'\xDCV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a(\xEEV[\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#\xD3Wa#\xD3a)LV[\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x03$a)\xDE\x83\x86a)\xB9V[\x84a)\xB9V[`\x01\x81\x81\x1C\x90\x82\x16\x80a)\xF8W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a*/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`\"`\x04R`$_\xFD[P\x91\x90PV[\x80T_\x90`\x01\x81\x81\x1C\x90\x82\x16\x80a*MW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a*\x84W\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[\x81\x86R` \x86\x01\x81\x80\x15a*\x9FW`\x01\x81\x14a*\xD3Wa*\xFFV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x85\x16\x82R\x83\x15\x15`\x05\x1B\x82\x01\x95Pa*\xFFV[_\x87\x81R` \x90 _[\x85\x81\x10\x15a*\xF9W\x81T\x84\x82\x01R`\x01\x90\x91\x01\x90` \x01a*\xDDV[\x83\x01\x96PP[PPPPP\x92\x91PPV[\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\x81T`\xE0\x1B\x16\x82R`\x80` \x83\x01R_a+K`\x80\x84\x01`\x01\x84\x01a*5V[\x83\x81\x03`@\x85\x01Ra+`\x81`\x02\x85\x01a*5V[\x90P\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`\x03\x84\x01T`\xE0\x1B\x16``\x85\x01R\x80\x91PP\x92\x91PPV[`@\x82R_a+\xAD`@\x84\x01\x83a+\nV[\x83\x81\x03` \x85\x01Ra\x03$\x81`\x04\x85\x01a*5V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x81R\x83` \x82\x01R`\x80`@\x82\x01R_a+\xF6`\x80\x83\x01\x85a+\x9BV[\x82\x81\x03``\x84\x01R\x83T\x81R`\x01\x84\x01T` \x82\x01R`\x80`@\x82\x01R`\xA0`\x80\x82\x01Ra,+a\x01 \x82\x01`\x02\x86\x01a*5V[`\x03\x85\x01T`\xA0\x83\x01R`\x7F\x19\x82\x82\x03\x01`\xC0\x83\x01Ra,N\x81`\x04\x87\x01a*5V[\x90P`\x05\x85\x01T`\xE0\x83\x01R`\x7F\x19\x82\x82\x03\x01a\x01\0\x83\x01Ra,t\x81`\x06\x87\x01a*5V[\x90P\x81\x81\x03``\x83\x01Ra,\x8B\x81`\x07\x87\x01a+\nV[\x98\x97PPPPPPPPV[_` \x82\x84\x03\x12\x15a,\xA7W__\xFD[PQ\x91\x90PV[\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\x81Q\x16\x82R_` \x82\x01Q`\x80` \x85\x01Ra,\xEE`\x80\x85\x01\x82a%\xCCV[\x90P`@\x83\x01Q\x84\x82\x03`@\x86\x01Ra-\x07\x82\x82a%\xCCV[\x91PP\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``\x84\x01Q\x16``\x85\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\x85\x16\x81R\x83` \x82\x01R`\x80`@\x82\x01R_a-t`\x80\x83\x01\x85a+\x9BV[\x82\x81\x03``\x84\x01R\x83Q\x81R` \x84\x01Q` \x82\x01R`@\x84\x01Q`\x80`@\x83\x01R\x80Q`\xA0`\x80\x84\x01Ra-\xADa\x01 \x84\x01\x82a%\xCCV[\x90P` \x82\x01Q`\xA0\x84\x01R`@\x82\x01Q`\x7F\x19\x84\x83\x03\x01`\xC0\x85\x01Ra-\xD4\x82\x82a%\xCCV[\x91PP``\x82\x01Q`\xE0\x84\x01R`\x80\x82\x01Q\x91P`\x7F\x19\x83\x82\x03\x01a\x01\0\x84\x01Ra-\xFF\x81\x83a%\xCCV[\x91PP``\x85\x01Q\x82\x82\x03``\x84\x01Ra.\x19\x82\x82a,\xAEV[\x99\x98PPPPPPPPPV[\x7F.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R_a.W`\x01\x83\x01\x86a)\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\x81Ra.\x87`\x01\x82\x01\x86a)\xB9V[\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\x81Ra.\xB9`\x02\x82\x01\x85a)\xB9V[\x96\x95PPPPPPV[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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.\xF3Wa.\xF3a)LV[P`\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`\x12`\x04R`$_\xFD[_\x82a/5Wa/5a.\xFAV[P\x04\x90V[_\x82a/HWa/Ha.\xFAV[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a#\xD3Wa#\xD3a)LV[`@\x81R_a/r`@\x83\x01\x85a%\xCCV[\x82\x81\x03` \x84\x01Ra/\x84\x81\x85a%\xCCV[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a/\x9DW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a/\xB3W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a/\xC3W__\xFD[\x80Qa/\xD1a%\x8B\x82a%\x1EV[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a/\xE5W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV\xFETx witness merkle proof is not valid for provided header and tx hash\xDC \xDA\xDE\xF4w\xFA\xAB(R\xF2\xF8\xAE\x0C\x82j\xA7\xE0\\M\xE0\xD3o\x0Ecc\x04)UH\x84\xC3q\xDAYt\xB6\xF3O\xA2\xC3Sg8\xF01\xB4\x9F4\xE0\xC9\xD0\x84\xD7(\x0F&!.9\0~\xBE\x9E\xA0\x87\x0C1'E\xB5\x81(\xA0\neW\x85\x1E\x98~\xCE\x02)M\x15o\0 3n\x15\x89(\xE8\x96B\x92d,lM\xC4i\xF3K{\xAC\xF2\xD8\xC4!\x15\xBA\xB6\xAF\xC9\x06\x7F.\xD3\x0E\x87Ir\x9Bc\xE0\x88\x9E >\xE5\x8E5Y\x03\xC1\xE7\x1Fx\xC0\x08\xDFl5\x97\xB2\xCCf\xD0\xB8\xAA\xE1\xA4\xA3<\xAAwT\x98\xE51\xCF\xB6\xAFX\xE8}\xB9\x9E\x0FSm\xD2&\xD1\x8FC\xE3\x86AH\xBA[\x7F\xAC\xA5\xC7u\xF1\x0B\xC8\x10\xC6\x02\xE1\xAF!\x95\xA3Ew\x97i!\xCE\0\x9AM\xDC\n\x07\xF6\x05\xC9k\x0F_\xCFX\x081\xEB\xBE\x01\xA3\x1F\xA2\x9B\xDE\x88F\t\xD2\x86\xDC\xCF\xA5\xBA\x8EU\x8C\xE3\x12[\xD4\xC3\xA1\x9E\x88\x8C\xF2hR(b\x02\xD2\xA7\xD3\x02\xC7^\x0F\xF5\xCA\x8F\xE7)\x9F\xB0\xD9\xD1\x13+\xF2\xC5l.;s\xDFy\x92\x86\x19=`\xC1\t\xB1\x87\xD6Eq\xEF\xBA\xA8\x04{\xE8X!\xF8\xE6~\x0E\x85\xF2\xF5\x89K\xC6=\0\xC2\xED\x9De\xE3Z\rm\xE9Kef\x94X\x99d\xA2R\x95~Fs\xA9\xFB\x1D/\x8BJ\x92\xE3\xF0\xA7\xBBeO\xDD\xB9NZ\x1Em\x7F\x7FI\x9F\xD1\xBE]\xD3\ns\xBFU\x84\xBF\x13}\xA5\xFD\xD7|\xC2\x1A\xEB\x95\xB9\xE3W\x88\x89K\xE0\x19(K\xD4\xFB\xEDm\xD6\x11\x8A\xC2\xCBm&\xBCK\xE4\xE4#\xF5Z:H\xF2\x87M\x8D\x02\xA3\x1B\xC4\xAC\xABO\xFEM\xCD$\x08J\x18x\xF71}\xEE\x84\r-N ^\x02\xEA\x9F\xC1\x16\x07\xC7.%\x05\xD2\x05\xB4\xD6B\xEB\xA1\xC4<\xEA\xD8\xDA\x15t\xE0\xE8\xA9:\xA8d+Q\xD5\xCAC\xF5!O\x1E\xD6\xEA\xBA\xF6(]\x83\xF4`\xB5o\xA9\xDDB8\x82\x16o\xDE\t\xA8\xF8\xEB%@f\xE6\xA0\xA4\xB4\xC0\x07!`\xC38j\x0BI\xE7_\x17#\xD6\xAB(\xAC\x9A (\xA0\xC7(f\xE2\x11\x1Dy\xD4\x81{\x88\xE1|\x82\x82!A\\5\x15\xB1\x8A&\xEF\x99\x83>\xE2M\xAAPe.\xA0\x1E\xF0!\xE3u'e\xB6\xCBMZ\x1E\xD3w\x08\xD9\xCDpxf_\x07\x11#\xA2\xC7\x8E\xCB\x98\xEA\xF3\xA3CKd:r\x12n\r>\xCDEQ\x12\xCB\xF3Q\x15a\xE8\xA0\xAC\xD7\x89\x01\xF1\xF2\xD0Z\xD7g&\xFD\x07~\x1B\x9C\xFD9C\x04j\x92\x95\xFBTx not on same level of merkle tree as coinbaseCoinbase merkle proof is not valid for provided header and hash\xA2dipfsX\"\x12 \xC60\x1D\x86\x1F\r\xCE\xB5\xD13a\xF4r,\xAC7\xD9s)$%\x8C\x06\xF4\x85K\xF0\xFD\r=\xCB4dsolcC\0\x08\x1C\x003`\x80`@R4\x80\x15`\x0EW__\xFD[Pa\x15\xD0\x80a\0\x1C_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0)W_5`\xE0\x1C\x80c\x97B>\xB4\x14a\0-W[__\xFD[a\0@a\0;6`\x04a\x12AV[a\0RV[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[_a\0_\x85\x85\x85\x85a\0jV[\x90P[\x94\x93PPPPV[_a\0u\x83\x83a\x01\x18V[\x90P_a\0\x89\x83`@\x01Q`@\x01Qa\x05\xB1V[`@Q\x7F\xE4q\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\x81\x01\x82\x90R`\xFF\x87\x16`$\x82\x01R\x90\x91Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x90c\xE4q\xE7,\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\0\xF9W__\xFD[PZ\xFA\x15\x80\x15a\x01\x0BW=__>=_\xFD[PPPPP\x94\x93PPPPV[_a\x01*\x82``\x01Q`@\x01Qa\x06\x89V[a\x01\xA1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FInvalid coinbase output vector p`D\x82\x01R\x7Frovided\0\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[\x82Q` \x01Qa\x01\xB0\x90a\x07#V[a\x02\"W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`%`$\x82\x01R\x7FInvalid payment input vector pro`D\x82\x01R\x7Fvided\0\0\0\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\x01\x98V[\x82Q`@\x01Qa\x021\x90a\x06\x89V[a\x02\xA3W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FInvalid payment output vector pr`D\x82\x01R\x7Fovided\0\0\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\x01\x98V[`@\x82\x01Q`\x80\x81\x01QQ\x90QQ\x14a\x03$W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`/`$\x82\x01R\x7FTx not on same level of merkle t`D\x82\x01R\x7Free as coinbase\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x01\x98V[``\x80\x83\x01Q\x80Q` \x80\x83\x01Q`@\x80\x85\x01Q\x94\x90\x95\x01Q\x94Q_\x95a\x03f\x95a\x03R\x95\x94\x90\x92\x01a\x13MV[`@Q` \x81\x83\x03\x03\x81R\x90`@Ra\x07\xB0V[\x90P_a\x03z\x84`@\x01Q`@\x01Qa\x07\xD2V[`@\x85\x01Q`\x80\x01Q\x90\x91Pa\x03\x94\x90\x83\x90\x83\x90_a\x07\xDEV[a\x04\x06W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`?`$\x82\x01R\x7FCoinbase merkle proof is not val`D\x82\x01R\x7Fid for provided header and hash\0`d\x82\x01R`\x84\x01a\x01\x98V[\x84Q\x80Q` \x80\x83\x01Q`@\x80\x85\x01Q\x83\x8B\x01Q``\x90\x96\x01Q\x91Q_\x96a\x04_\x96a\x03R\x96\x90\x95\x89\x95\x7F\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\x95\x91\x94\x91\x93\x92\x90\x91\x01a\x13\xBCV[` \x80\x87\x01Q`@\x88\x01Q\x80Q\x92\x01Q\x92\x93Pa\x04~\x92\x84\x92\x90a\x07\xDEV[a\x05\x17W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`D`$\x82\x01\x81\x90R\x7FTx witness merkle proof is not v\x90\x82\x01R\x7Falid for provided header and tx `d\x82\x01R\x7Fhash\0\0\0\0\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\x82\x01R`\xA4\x01a\x01\x98V[_a\x05>\x86` \x01Q\x87_\x01Q`@Q` \x01a\x03R\x92\x91\x90\x91\x82R` \x82\x01R`@\x01\x90V[\x90P_a\x05R\x87``\x01Q`@\x01Qa\x08\x10V[\x90P\x81\x81\x14a\x05\xA3W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x12`$\x82\x01R\x7FInvalid commitment\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x01\x98V[P\x90\x93PPPP[\x92\x91PPV[_`\x02\x80\x83`@Qa\x05\xC3\x91\x90a\x14\x81V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x05\xDEW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x01\x91\x90a\x14\x8CV[`@Q` \x01a\x06\x13\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\x90\x82\x90Ra\x06K\x91a\x14\x81V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x06fW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xAB\x91\x90a\x14\x8CV[___a\x06\x95\x84a\t\xE9V[\x90\x92P\x90P\x80\x15\x80a\x06\xA7WP_\x19\x82\x14[\x15a\x06\xB5WP_\x93\x92PPPV[_a\x06\xC1\x83`\x01a\x14\xD0V[\x90P_[\x82\x81\x10\x15a\x07\x16W\x85Q\x82\x10a\x06\xE0WP_\x95\x94PPPPPV[_a\x06\xEB\x87\x84a\t\xFEV[\x90P_\x19\x81\x03a\x07\x01WP_\x96\x95PPPPPPV[a\x07\x0B\x81\x84a\x14\xD0V[\x92PP`\x01\x01a\x06\xC5V[P\x93Q\x90\x93\x14\x93\x92PPPV[___a\x07/\x84a\t\xE9V[\x90\x92P\x90P\x80\x15\x80a\x07AWP_\x19\x82\x14[\x15a\x07OWP_\x93\x92PPPV[_a\x07[\x83`\x01a\x14\xD0V[\x90P_[\x82\x81\x10\x15a\x07\x16W\x85Q\x82\x10a\x07zWP_\x95\x94PPPPPV[_a\x07\x85\x87\x84a\ngV[\x90P_\x19\x81\x03a\x07\x9BWP_\x96\x95PPPPPPV[a\x07\xA5\x81\x84a\x14\xD0V[\x92PP`\x01\x01a\x07_V[_` _\x83Q` \x85\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x91\x90PV[`D\x81\x01Q_\x90a\x05\xABV[_\x83\x85\x14\x80\x15a\x07\xECWP\x81\x15[\x80\x15a\x07\xF7WP\x82Q\x15[\x15a\x08\x04WP`\x01a\0bV[a\0_\x85\x84\x86\x85a\n\xADV[___a\x08\x1C\x84a\t\xE9V[\x90\x92P\x90P`\x01\x82\x01a\x08\x97W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\"`$\x82\x01R\x7FRead overrun during VarInt parsi`D\x82\x01R\x7Fng\0\0\0\0\0\0\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\x01\x98V[_\x80a\x08\xA4\x84`\x01a\x14\xD0V[\x90P_[\x83\x81\x10\x15a\t\xDDWa\x08\xBA\x87\x83a\t\xFEV[\x92P_\x19\x83\x03a\t\x0CW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FBad VarInt in scriptPubkey\0\0\0\0\0\0`D\x82\x01R`d\x01a\x01\x98V[_a\t\x18\x88\x84\x86a\x0BRV[\x90P\x80`\x08\x81Q\x81\x10a\t-Wa\t-a\x14\xE3V[\x01` \x01Q\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\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\x03a\t\xC8W_a\t\x88\x82`\t`&a\x0BRV[\x90Pa\t\x93\x81a\x0C\x1DV[\x15a\t\xC6Wa\t\xB0`\x06a\t\xA8\x81`&a\x15\x10V[\x83\x91\x90a\x0BRV[a\t\xB9\x90a\x15#V[\x99\x98PPPPPPPPPV[P[a\t\xD2\x84\x84a\x14\xD0V[\x92PP`\x01\x01a\x08\xA8V[P_\x96\x95PPPPPPV[__a\t\xF5\x83_a\x0CwV[\x91P\x91P\x91P\x91V[_a\n\n\x82`\ta\x14\xD0V[\x83Q\x10\x15a\n\x1AWP_\x19a\x05\xABV[_\x80a\n0\x85a\n+\x86`\x08a\x14\xD0V[a\x0CwV[\x90\x92P\x90P`\x01\x82\x01a\nHW_\x19\x92PPPa\x05\xABV[\x80a\nT\x83`\ta\x14\xD0V[a\n^\x91\x90a\x14\xD0V[\x95\x94PPPPPV[___a\nt\x85\x85a\x0E\x14V[\x90\x92P\x90P`\x01\x82\x01a\n\x8CW_\x19\x92PPPa\x05\xABV[\x80a\n\x98\x83`%a\x14\xD0V[a\n\xA2\x91\x90a\x14\xD0V[a\n^\x90`\x04a\x14\xD0V[_` \x84Qa\n\xBC\x91\x90a\x15IV[\x15a\n\xC8WP_a\0bV[\x83Q_\x03a\n\xD7WP_a\0bV[\x81\x85_[\x86Q\x81\x10\x15a\x0BEWa\n\xEF`\x02\x84a\x15IV[`\x01\x03a\x0B\x13Wa\x0B\x0Ca\x0B\x06\x88\x83\x01` \x01Q\x90V[\x83a\x0ERV[\x91Pa\x0B,V[a\x0B)\x82a\x0B$\x89\x84\x01` \x01Q\x90V[a\x0ERV[\x91P[`\x01\x92\x90\x92\x1C\x91a\x0B>` \x82a\x14\xD0V[\x90Pa\n\xDBV[P\x90\x93\x14\x95\x94PPPPPV[``\x81_\x03a\x0BoWP`@\x80Q` \x81\x01\x90\x91R_\x81Ra\x0C\x16V[_a\x0Bz\x83\x85a\x14\xD0V[\x90P\x83\x81\x11\x80\x15a\x0B\x8CWP\x80\x85Q\x10\x15[a\x0B\xD8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FSlice out of bounds\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x01\x98V[`@Q\x91P\x82`@\x83\x01\x01`@R\x82\x82R\x83\x85\x01\x82\x03\x84` \x87\x01\x01\x84\x81\x01[\x80\x82\x10\x15a\x0C\x11W\x81Q\x83\x83\x01R` \x82\x01\x91Pa\x0B\xF8V[PPPP[\x93\x92PPPV[_`&\x82Q\x10\x15\x80\x15a\x05\xABWPP` \x01Q\x7F\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\0\0\x16\x7Fj$\xAA!\xA9\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\x14\x90V[___a\x0C\x84\x85\x85a\x0E]V[\x90P\x80`\xFF\x16_\x03a\x0C\xB7W_\x85\x85\x81Q\x81\x10a\x0C\xA3Wa\x0C\xA3a\x14\xE3V[\x01` \x01Q\x90\x93P`\xF8\x1C\x91Pa\x0E\r\x90PV[\x83a\x0C\xC3\x82`\x01a\x15\x81V[`\xFF\x16a\x0C\xD0\x91\x90a\x14\xD0V[\x85Q\x10\x15a\x0C\xE5W_\x19_\x92P\x92PPa\x0E\rV[_\x81`\xFF\x16`\x02\x03a\r(Wa\r\x1Da\r\ta\r\x02\x87`\x01a\x14\xD0V[\x88\x90a\x0E\xE1V[b\xFF\xFF\0`\xE8\x82\x90\x1C\x16`\xF8\x91\x90\x91\x1C\x17\x90V[a\xFF\xFF\x16\x90Pa\x0E\x03V[\x81`\xFF\x16`\x04\x03a\rwWa\rja\rDa\r\x02\x87`\x01a\x14\xD0V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[c\xFF\xFF\xFF\xFF\x16\x90Pa\x0E\x03V[\x81`\xFF\x16`\x08\x03a\x0E\x03Wa\r\xF6a\r\x93a\r\x02\x87`\x01a\x14\xD0V[`\xC0\x1Cd\xFF\0\0\0\xFF`\x08\x82\x81\x1C\x91\x82\x16e\xFF\0\0\0\xFF\0\x93\x90\x91\x1B\x92\x83\x16\x17`\x10\x90\x81\x1Bg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16f\xFF\0\xFF\0\xFF\0\xFF\x92\x90\x92\x16g\xFF\0\xFF\0\xFF\0\xFF\0\x90\x93\x16\x92\x90\x92\x17\x90\x91\x1Ce\xFF\xFF\0\0\xFF\xFF\x16\x17` \x81\x81\x1C\x91\x90\x1B\x17\x90V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P[`\xFF\x90\x91\x16\x92P\x90P[\x92P\x92\x90PV[_\x80a\x0E!\x83`%a\x14\xD0V[\x84Q\x10\x15a\x0E4WP_\x19\x90P_a\x0E\rV[_\x80a\x0EE\x86a\n+\x87`$a\x14\xD0V[\x90\x97\x90\x96P\x94PPPPPV[_a\x0C\x16\x83\x83a\x0E\xEFV[_\x82\x82\x81Q\x81\x10a\x0EpWa\x0Epa\x14\xE3V[\x01` \x01Q`\xF8\x1C`\xFF\x03a\x0E\x87WP`\x08a\x05\xABV[\x82\x82\x81Q\x81\x10a\x0E\x99Wa\x0E\x99a\x14\xE3V[\x01` \x01Q`\xF8\x1C`\xFE\x03a\x0E\xB0WP`\x04a\x05\xABV[\x82\x82\x81Q\x81\x10a\x0E\xC2Wa\x0E\xC2a\x14\xE3V[\x01` \x01Q`\xF8\x1C`\xFD\x03a\x0E\xD9WP`\x02a\x05\xABV[P_\x92\x91PPV[_a\x0C\x16\x83\x83\x01` \x01Q\x90V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\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`A`\x04R`$_\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0FfWa\x0Ffa\x0F\x16V[`@R\x90V[`@Q`\xA0\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0FfWa\x0Ffa\x0F\x16V[`@\x80Q\x90\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0FfWa\x0Ffa\x0F\x16V[\x805\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\x0F\xE1W__\xFD[\x91\x90PV[_\x82`\x1F\x83\x01\x12a\x0F\xF5W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10\x0FWa\x10\x0Fa\x0F\x16V[`@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\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x10\\Wa\x10\\a\x0F\x16V[`@R\x81\x81R\x83\x82\x01` \x01\x85\x10\x15a\x10sW__\xFD[\x81` \x85\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[_`\x80\x82\x84\x03\x12\x15a\x10\x9FW__\xFD[a\x10\xA7a\x0FCV[\x90Pa\x10\xB2\x82a\x0F\xB2V[\x81R` \x82\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10\xCDW__\xFD[a\x10\xD9\x84\x82\x85\x01a\x0F\xE6V[` \x83\x01RP`@\x82\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10\xF8W__\xFD[a\x11\x04\x84\x82\x85\x01a\x0F\xE6V[`@\x83\x01RPa\x11\x16``\x83\x01a\x0F\xB2V[``\x82\x01R\x92\x91PPV[_`\x80\x82\x84\x03\x12\x15a\x111W__\xFD[a\x119a\x0FCV[\x825\x81R` \x80\x84\x015\x90\x82\x01R\x90P`@\x82\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x11bW__\xFD[\x82\x01`\xA0\x81\x85\x03\x12\x15a\x11sW__\xFD[a\x11{a\x0FlV[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x11\x91W__\xFD[a\x11\x9D\x86\x82\x85\x01a\x0F\xE6V[\x82RP` \x82\x81\x015\x90\x82\x01R`@\x82\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x11\xC3W__\xFD[a\x11\xCF\x86\x82\x85\x01a\x0F\xE6V[`@\x83\x01RP``\x82\x81\x015\x90\x82\x01R`\x80\x82\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x11\xF8W__\xFD[a\x12\x04\x86\x82\x85\x01a\x0F\xE6V[`\x80\x83\x01RP`@\x83\x01RP``\x82\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12)W__\xFD[a\x125\x84\x82\x85\x01a\x10\x8FV[``\x83\x01RP\x92\x91PPV[____`\x80\x85\x87\x03\x12\x15a\x12TW__\xFD[\x845s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x12wW__\xFD[\x93P` \x85\x015\x92P`@\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\x99W__\xFD[\x85\x01`@\x81\x88\x03\x12\x15a\x12\xAAW__\xFD[a\x12\xB2a\x0F\x8FV[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\xC8W__\xFD[a\x12\xD4\x89\x82\x85\x01a\x10\x8FV[\x82RP` \x82\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\xF0W__\xFD[a\x12\xFC\x89\x82\x85\x01a\x0F\xE6V[` \x83\x01RP\x92PP``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x13\x1EW__\xFD[a\x13*\x87\x82\x88\x01a\x11!V[\x91PP\x92\x95\x91\x94P\x92PV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[\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\x85\x16\x81R_a\x13\x89a\x13\x83`\x04\x84\x01\x87a\x136V[\x85a\x136V[\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\x93\x90\x93\x16\x83RPP`\x04\x01\x93\x92PPPV[\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\x88\x16\x81R\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\x87\x16`\x04\x82\x01R\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\x86\x16`\x05\x82\x01R_a\x14Ka\x13\x83a\x14E`\x06\x85\x01\x89a\x136V[\x87a\x136V[\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\x93\x90\x93\x16\x83RPP`\x04\x01\x96\x95PPPPPPV[_a\x0C\x16\x82\x84a\x136V[_` \x82\x84\x03\x12\x15a\x14\x9CW__\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\x05\xABWa\x05\xABa\x14\xA3V[\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\x05\xABWa\x05\xABa\x14\xA3V[\x80Q` \x80\x83\x01Q\x91\x90\x81\x10\x15a\x15CW_\x19\x81` \x03`\x03\x1B\x1B\x82\x16\x91P[P\x91\x90PV[_\x82a\x15|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`\x12`\x04R`$_\xFD[P\x06\x90V[`\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x05\xABWa\x05\xABa\x14\xA3V\xFE\xA2dipfsX\"\x12 8\xBF_\x13\xEFL\xD8\xE4T\xF2\xF8\x10h\xC2Y\x05\x03\x04\x1B\x7F\x0EB\xE8\xC4\xFF\xCFjLJ\x80\x1A\xBCdsolcC\0\x08\x1C\x003`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa);8\x03\x80a);\x839\x81\x01`@\x81\x90Ra\0.\x91a\x03+V[\x82\x82\x82\x82\x82\x82a\0?\x83Q`P\x14\x90V[a\0\x84W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x11`$\x82\x01RpBad genesis block`x\x1B`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\0\x8E\x84a\x01fV[\x90Pb\xFF\xFF\xFF\x82\x16\x15a\x01\tW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FPeriod start hash does not have `D\x82\x01R\x7Fwork. Hint: wrong byte order?\0\0\0`d\x82\x01R`\x84\x01a\0{V[_\x81\x81U`\x01\x82\x90U`\x02\x82\x90U\x81\x81R`\x04` R`@\x90 \x83\x90Ua\x012a\x07\xE0\x84a\x03\xFEV[a\x01<\x90\x84a\x04%V[_\x83\x81R`\x04` R`@\x90 Ua\x01S\x84a\x02&V[`\x05UPa\x05\xBD\x98PPPPPPPPPV[_`\x02\x80\x83`@Qa\x01x\x91\x90a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\x93W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x04NV[`@Q` \x01a\x01\xC8\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x01\xE2\x91a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\xFDW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02 \x91\x90a\x04NV[\x92\x91PPV[_a\x02 a\x023\x83a\x028V[a\x02CV[_a\x02 \x82\x82a\x02SV[_a\x02 a\xFF\xFF`\xD0\x1B\x83a\x02\xF7V[_\x80a\x02ja\x02c\x84`Ha\x04eV[\x85\x90a\x03\tV[`\xE8\x1C\x90P_\x84a\x02|\x85`Ka\x04eV[\x81Q\x81\x10a\x02\x8CWa\x02\x8Ca\x04xV[\x01` \x01Q`\xF8\x1C\x90P_a\x02\xBE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x02\xD1`\x03\x84a\x04\x8CV[`\xFF\x16\x90Pa\x02\xE2\x81a\x01\0a\x05\x88V[a\x02\xEC\x90\x83a\x05\x93V[\x97\x96PPPPPPPV[_a\x03\x02\x82\x84a\x05\xAAV[\x93\x92PPPV[_a\x03\x02\x83\x83\x01` \x01Q\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x03=W__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03RW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03bW__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03{Wa\x03{a\x03\x17V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x03\xA9Wa\x03\xA9a\x03\x17V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x03\xC0W__\xFD[\x81` \x84\x01` \x83\x01^_` \x92\x82\x01\x83\x01R\x90\x86\x01Q`@\x90\x96\x01Q\x90\x97\x95\x96P\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x04\x0CWa\x04\x0Ca\x03\xEAV[P\x06\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x04^W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02 Wa\x02 a\x04\x11V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[`\x01\x81[`\x01\x84\x11\x15a\x04\xE0W\x80\x85\x04\x81\x11\x15a\x04\xC4Wa\x04\xC4a\x04\x11V[`\x01\x84\x16\x15a\x04\xD2W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x04\xA9V[\x93P\x93\x91PPV[_\x82a\x04\xF6WP`\x01a\x02 V[\x81a\x05\x02WP_a\x02 V[\x81`\x01\x81\x14a\x05\x18W`\x02\x81\x14a\x05\"Wa\x05>V[`\x01\x91PPa\x02 V[`\xFF\x84\x11\x15a\x053Wa\x053a\x04\x11V[PP`\x01\x82\x1Ba\x02 V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x05aWP\x81\x81\na\x02 V[a\x05m_\x19\x84\x84a\x04\xA5V[\x80_\x19\x04\x82\x11\x15a\x05\x80Wa\x05\x80a\x04\x11V[\x02\x93\x92PPPV[_a\x03\x02\x83\x83a\x04\xE8V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x02 Wa\x02 a\x04\x11V[_\x82a\x05\xB8Wa\x05\xB8a\x03\xEAV[P\x04\x90V[a#q\x80a\x05\xCA_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\xADW\x80c\xB9\x85b\x1A\x11a\0}W\x80c\xE3\xD8\xD8\xD8\x11a\0cW\x80c\xE3\xD8\xD8\xD8\x14a\x02\"W\x80c\xE4q\xE7,\x14a\x02)W\x80c\xF5\x8D\xB0o\x14a\x02=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x13\x91\x90a!WV[`@Q` \x01a\x0C%\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\x90\x82\x90Ra\x0C]\x91a!AV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0CxW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x07\x91\x90a!WV[_\x83\x85\x14\x80\x15a\x0C\xAAWP\x82\x85\x14[\x15a\x0C\xB7WP`\x01a\x04\xF1V[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x0C\xFFW\x89\x83\x14a\x0C\xDEW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x0C\xF7W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x0C\xBDV[P\x82\x84\x03a\r\x13W_\x94PPPPPa\x04\xF1V[\x80\x82\x14a\r&W_\x94PPPPPa\x04\xF1V[P`\x01\x98\x97PPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\rYW_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\r9V[P\x80a\x05\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x80\x82\x81[a\r\xB8`\x04`\x01a!\x9BV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0E\x0CW_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\r\xF1W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0E\x04V[a\r\xFB\x81\x84a!\xB7V[\x95\x94PPPPPV[`\x01\x01a\r\xACV[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_`P\x82Qa\x0B~\x91\x90a!.V[__a\x0Eo\x85a\x0B\xC3V[\x90P_a\x0E{\x82a\r\xA7V[\x90P_a\x0E\x87\x86a\x19\xE6V[\x90P\x84\x80a\x0E\x9CWP\x80a\x0E\x9A\x88a\x19\xE6V[\x14[a\x0F\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x03.V[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x12\x0EWa\x0F(`P\x82a!\xCAV[a\x0F3\x90`\x01a!\xB7V[a\x0F=\x90\x87a!\xB7V[\x93Pa\x0FK\x8A\x82`Pa\x19\xF1V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x11!W\x84a\x10\xA1\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x10\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x11\n`\x04\x85a!.V[_\x03a\x11!W_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x11,\x8B\x83a\x1A\x16V[\x14a\x11yW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[\x86a\x11\x84\x8B\x83a\x1A\xAFV[\x14a\x11\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x03.V[\x82\x96P`P\x81a\x12\x07\x91\x90a!\xB7V[\x90Pa\x0F\x15V[P\x81a\x12\x19\x8Ba\x0B\xC3V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x12\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x12\xD4\x84a\x0B\xC3V[\x90P_a\x12\xE0\x86a\x0B\xC3V[\x90P`\x01T\x81\x14a\x133W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x03.V[_\x82\x81R`\x03` R`@\x90 Ta\x13\x8DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x13\x9B\x87`\x01T\x84\x87a\x0C\x9BV[a\x14\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x03.V[\x81a\x14\x19\x88\x88\x88a\x17\x80V[\x14a\x14\x8CW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[`\x01\x82\x90U`\x02\x87\x90U_a\x14\xA0\x86a\x1A\xC7V[\x90P`\x05T\x81\x14a\x14\xB1W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x15\x01a\x14\xFC\x86a\x0B\xC3V[a\r\xA7V[\x90P_a\x15\x10a\x14\xFC\x86a\x0B\xC3V[\x90Pa\x15\x1Ea\x07\xE0\x82a!.V[a\x07\xDF\x14a\x15\x94W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x03.V[a\x15\xA0\x82a\x07\xDFa!\xB7V[\x81\x14a\x16\x14W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x03.V[a\x16\x1D\x85a\x1A\xC7V[a\x16&\x87a\x1A\xC7V[\x14a\x16\x99W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x03.V[_a\x16\xA3\x85a\x19\xE6V[\x90P_a\x16\xD5a\x16\xB2\x89a\x19\xE6V[a\x16\xBB\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x16\xCA\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x1B\x0CV[\x90P\x81\x81\x83\x16\x14a\x17(W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_a\x172\x89a\x1A\xC7V[\x90P\x80`\x06T\x14\x15\x80\x15a\x17\\WPa\x07\xE0a\x17O`\x01Ta\r\xA7V[a\x17Y\x91\x90a!\xDDV[\x84\x11[\x15a\x17gW`\x06\x81\x90U[a\x17s\x88\x88`\x01a\x0EdV[\x99\x98PPPPPPPPPV[__a\x17\x8B\x85a\r\xA7V[\x90P_a\x17\x9Aa\x14\xFC\x86a\x0B\xC3V[\x90P_a\x17\xA9a\x14\xFC\x86a\x0B\xC3V[\x90P\x82\x82\x10\x15\x80\x15a\x17\xBBWP\x82\x81\x10\x15[a\x18-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x18:a\x07\xE0\x85a!.V[a\x18F\x85a\x07\xE0a!\xB7V[a\x18P\x91\x90a!\xDDV[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x18bWP\x80[\x15a\x18}Wa\x18p\x89a\x0B\xC3V[\x96PPPPPPPa\n\xA3V[\x81\x80\x15a\x18\x88WP\x80\x15[\x15a\x18\x96Wa\x18p\x88a\x0B\xC3V[\x81\x80\x15a\x18\xA0WP\x80[\x15a\x18\xC4W\x83\x85\x10\x15a\x18\xBBWa\x18\xB6\x88a\x0B\xC3V[a\x18pV[a\x18p\x89a\x0B\xC3V[a\x18\xCD\x88a\x1A\xC7V[a\x18\xD9a\x07\xE0\x86a!.V[a\x18\xE3\x91\x90a!\xF0V[a\x18\xEC\x8Aa\x1A\xC7V[a\x18\xF8a\x07\xE0\x88a!.V[a\x19\x02\x91\x90a!\xF0V[\x10\x15a\x18\xBBWa\x18p\x88a\x0B\xC3V[`\x07T_\x90`\xFF\x16\x15a\x19/WP`\x07Ta\x01\0\x90\x04`\xFF\x16a\n\xA3V[a\x19:\x84\x84\x84a\x1B\x94V[\x90Pa\n\xA3V[_` \x84Qa\x19P\x91\x90a!.V[\x15a\x19\\WP_a\x04\xF1V[\x83Q_\x03a\x19kWP_a\x04\xF1V[\x81\x85_[\x86Q\x81\x10\x15a\x19\xD9Wa\x19\x83`\x02\x84a!.V[`\x01\x03a\x19\xA7Wa\x19\xA0a\x19\x9A\x88\x83\x01` \x01Q\x90V[\x83a\x1B\xD5V[\x91Pa\x19\xC0V[a\x19\xBD\x82a\x19\xB8\x89\x84\x01` \x01Q\x90V[a\x1B\xD5V[\x91P[`\x01\x92\x90\x92\x1C\x91a\x19\xD2` \x82a!\xB7V[\x90Pa\x19oV[P\x90\x93\x14\x95\x94PPPPPV[_a\x05\x07\x82_a\x1A\x16V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x1A-a\x1A&\x84`Ha!\xB7V[\x85\x90a\x1B\xE0V[`\xE8\x1C\x90P_\x84a\x1A?\x85`Ka!\xB7V[\x81Q\x81\x10a\x1AOWa\x1AOa\"\x07V[\x01` \x01Q`\xF8\x1C\x90P_a\x1A\x81\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1A\x94`\x03\x84a\"4V[`\xFF\x16\x90Pa\x1A\xA5\x81a\x01\0a#0V[a\x08-\x90\x83a!\xF0V[_a\x05\x04a\x1A\xBE\x83`\x04a!\xB7V[\x84\x01` \x01Q\x90V[_a\x05\x07a\x1A\xD4\x83a\x19\xE6V[a\x1B\xEEV[_a\x05\x07a\x1A\xE6\x83a\x1C\x15V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1B\x18\x83\x85a\x1C!V[\x90Pa\x1B(b\x12u\0`\x04a\x1C|V[\x81\x10\x15a\x1B@Wa\x1B=b\x12u\0`\x04a\x1C|V[\x90P[a\x1BNb\x12u\0`\x04a\x1C\x87V[\x81\x11\x15a\x1BfWa\x1Bcb\x12u\0`\x04a\x1C\x87V[\x90P[_a\x1B~\x82a\x1Bx\x88b\x01\0\0a\x1C|V[\x90a\x1C\x87V[\x90Pa\n\x8Ab\x01\0\0a\x1Bx\x83b\x12u\0a\x1C|V[_\x82\x81[\x83\x81\x10\x15a\x1B\xCAW\x85\x82\x03a\x1B\xB2W`\x01\x92PPPa\n\xA3V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x1B\x98V[P_\x95\x94PPPPPV[_a\x05\x04\x83\x83a\x1C\xFAV[_a\x05\x04\x83\x83\x01` \x01Q\x90V[_a\x05\x07{\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\x83a\x1C|V[_a\x05\x07\x82`Da\x1B\xE0V[_\x82\x82\x11\x15a\x1CrW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x05\x04\x82\x84a!\xDDV[_a\x05\x04\x82\x84a!\xCAV[_\x82_\x03a\x1C\x96WP_a\x05\x07V[a\x1C\xA0\x82\x84a!\xF0V[\x90P\x81a\x1C\xAD\x84\x83a!\xCAV[\x14a\x05\x07W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x03.V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1D1W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DHW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1D_W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1DvW__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1D\x91W__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xA7W__\xFD[a\x1D\xB3\x8A\x82\x8B\x01a\x1D!V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xD2W__\xFD[a\x1D\xDE\x8A\x82\x8B\x01a\x1D!V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1D\xFE`\x80\x89\x01a\x1DfV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[____`\x80\x85\x87\x03\x12\x15a\x1E\x1FW__\xFD[PP\x825\x94` \x84\x015\x94P`@\x84\x015\x93``\x015\x92P\x90PV[__`@\x83\x85\x03\x12\x15a\x1ELW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1EkW__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1E\x85W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x9BW__\xFD[a\x1E\xA7\x87\x82\x88\x01a\x1D!V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\xC6W__\xFD[a\x1E\xD2\x87\x82\x88\x01a\x1D!V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1E\xF3W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x10W__\xFD[a\x1F\x1C\x89\x82\x8A\x01a\x1D!V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F;W__\xFD[a\x1FG\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1FtW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x8AW__\xFD[a\x1F\x96\x89\x82\x8A\x01a\x1D!V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xB5W__\xFD[a\x1F\xC1\x89\x82\x8A\x01a\x1D!V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xE0W__\xFD[a\x1F\xEC\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_____``\x86\x88\x03\x12\x15a \x12W__\xFD[\x855\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a /W__\xFD[a ;\x88\x82\x89\x01a\x1D!V[\x90\x95P\x93PP`@\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a ZW__\xFD[a f\x88\x82\x89\x01a\x1D!V[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[___``\x84\x86\x03\x12\x15a \x89W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a \xB1W__\xFD[\x825\x91Pa \xC1` \x84\x01a\x1DfV[\x90P\x92P\x92\x90PV[\x805\x80\x15\x15\x81\x14a\x1DvW__\xFD[__`@\x83\x85\x03\x12\x15a \xEAW__\xFD[a \xF3\x83a \xCAV[\x91Pa \xC1` \x84\x01a \xCAV[\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!\xA9m\xA5\xCFi_\"\xBF}\x94\xBE\x87\xD4\x9D\xB1\xADz\xC3q\xACC\xC4\xDAAa\xC8\xC2\x164\x9C[\xA1\x19(\x17\r8x+\0\0\0\0\0\0\0\0\0\0\0\0q\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x03\xAD\xE4\xC3J\0\0\0\0\x16\0\x14\x97\xCF\xC7dB\xFEq\x7F*?\x0C\xC9\xC1u\xF7V\x1Bf\x19\x97\0\0\0\0\0\0\0\0&j$\xAA!\xA9\xEDk9\xCA\xC5\xAF/{\xB8\xB9\x8F\xFB\xFC\x99T)\x9Eud\xDE\xC1\xA7\x8A\x9A\xC2\x98\xA3\t\x01\xA0\x11\x8Eg\0\0\0\0\0\0\0\0)RSKBLOCK:\xF9J\xDE(\"\xA7\xA3A_\xE8!\x80\\>\xD1\x10\xDA>\xE5\x8A!\xCAgE4\xFF\xE6^\xE8\x94a\xD7\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\xFF\xFF\xFF\xFFK\x03\x04C\x08\x04\x194\x9C[c/BTC.COM/\xFA\xBEmm\0\xE8\xFB]\xFAC\x84\x82\xDE.\x8A'/\x01\x8A\x96\xBE\x1D\xC3V.\x8D\xDF\x95\xB7\\ \xF7L\x02\xC7\xFF\x01\0\0\0\0\0\0\0n\xDC\xE8\x95\x13=\0\0\0\0\0\0\xFF\xFF\xFF\xFF\x02H\x97\x07\0\0\0\0\0\"\0 \xA43>V\x12\xAB\x1A\x10C\xB2WU\xC8\x9B\x16\xD5Q\x84\xA4/\x81y\x9Eb>k\xC3\x9D\xB8S\x9C\x18\0\0\0\0\0\0\0\0\x16j\x14\xED\xB1\xB5\xC2\xF3\x9A\xF0\xFE\xC1Qs%\x85\xB1\x04\x9B\x07\x89R\x11\xE3Z\rm\xE9Kef\x94X\x99d\xA2R\x95~Fs\xA9\xFB\x1D/\x8BJ\x92\xE3\xF0\xA7\xBBeO\xDD\xB9NZ\x1Em\x7F\x7FI\x9F\xD1\xBE]\xD3\ns\xBFU\x84\xBF\x13}\xA5\xFD\xD7|\xC2\x1A\xEB\x95\xB9\xE3W\x88\x89K\xE0\x19(K\xD4\xFB\xEDm\xD6\x11\x8A\xC2\xCBm&\xBCK\xE4\xE4#\xF5Z:H\xF2\x87M\x8D\x02\xA6]\x9C\x87\xD0}\xE2\x1DM\xFE{\n\x9FJ#\xCC\x9AX7>\x9Ei1\xFE\xFD\xB5\xAF\xAD\xE5\xDFT\xC9\x11\x04\x04\x8D\xF1\xEE\x99\x92@ay\x84\xE1\x8Bo\x93\x1E#sg=\x01\x95\xB8\xC6\x98}\x7F\xF7e\r\\\xE5;\xCE\xC4n\x13\xABO-\xA1\x14j\x7F\xC6!\xEEg/b\xBC\"t$\x869-u\xE5^g\xB0\x99`\xC38j\x0BI\xE7_\x17#\xD6\xAB(\xAC\x9A (\xA0\xC7(f\xE2\x11\x1Dy\xD4\x81{\x88\xE1|\x82\x197\x84wh\xD9(7\xBA\xE3\x83+\xB8\xE5\xA4\xABD4\xB9~\0\xA6\xC1\x01\x82\xF2\x11\xF5\x92@\x90h\xD6\xF5e$\0\xD9\xA3\xD1\xCC\x15\n\x7F\xB6\x92\xE8t\xCCB\xD7k\xDA\xFC\x84//\xE0\xF85\xA7\xC2M-`\xC1\t\xB1\x87\xD6Eq\xEF\xBA\xA8\x04{\xE8X!\xF8\xE6~\x0E\x85\xF2\xF5\x89K\xC6=\0\xC2\xED\x9Dd\x02G0D\x02 'n\x0E\xC7\x80(X T\xD8f\x14\xC6[\xC4\xBF\x85\xFFW\x10\xB9\xD3\xA2H\xCA(\xDD1\x1E\xB2\xFAh\x02 .\xC9P\xDD*\x8C\x945\xFF-@\x0C\xC4]zHT\xAE\x08_I\xE0\\\xC3\xF5\x03\x83EF\xD4\x10\xDE\x01!\x03s'\x83\xEE\xF3\xAF~\x04\xD3\xAFDD0\xA6)\xB1j\x92a\xE4\x02_R\xBFMm\x02b\x99\xC3|t\x01\x17F\xBD\x86t\0\xF3IK\x8FD\xC2K\x83\xE1\xAAX\xC4\xF0\xFF%\xB4\xA6\x1C\xFF\xEF\xFDK\xC0\xF9\xBA0\0\0\0\0\0\xFF\xFF\xFF\xFF\xDC \xDA\xDE\xF4w\xFA\xAB(R\xF2\xF8\xAE\x0C\x82j\xA7\xE0\\M\xE0\xD3o\x0Ecc\x04)UH\x84\xC3q\xDAYt\xB6\xF3O\xA2\xC3Sg8\xF01\xB4\x9F4\xE0\xC9\xD0\x84\xD7(\x0F&!.9\0~\xBE\x9E\xA0\x87\x0C1'E\xB5\x81(\xA0\neW\x85\x1E\x98~\xCE\x02)M\x15o\0 3n\x15\x89(\xE8\x96B\x92d,lM\xC4i\xF3K{\xAC\xF2\xD8\xC4!\x15\xBA\xB6\xAF\xC9\x06\x7F.\xD3\x0E\x87Ir\x9Bc\xE0\x88\x9E >\xE5\x8E5Y\x03\xC1\xE7\x1Fx\xC0\x08\xDFl5\x97\xB2\xCCf\xD0\xB8\xAA\xE1\xA4\xA3<\xAAwT\x98\xE51\xCF\xB6\xAFX\xE8}\xB9\x9E\x0FSm\xD2&\xD1\x8FC\xE3\x86AH\xBA[\x7F\xAC\xA5\xC7u\xF1\x0B\xC8\x10\xC6\x02\xE1\xAF!\x95\xA3Ew\x97i!\xCE\0\x9AM\xDC\n\x07\xF6\x05\xC9k\x0F_\xCFX\x081\xEB\xBE\x01\xA3\x1F\xA2\x9B\xDE\x88F\t\xD2\x86\xDC\xCF\xA5\xBA\x8EU\x8C\xE3\x12[\xD4\xC3\xA1\x9E\x88\x8C\xF2hR(b\x02\xD2\xA7\xD3\x02\xC7^\x0F\xF5\xCA\x8F\xE7)\x9F\xB0\xD9\xD1\x13+\xF2\xC5l.;s\xDFy\x92\x86\x19=`\xC1\t\xB1\x87\xD6Eq\xEF\xBA\xA8\x04{\xE8X!\xF8\xE6~\x0E\x85\xF2\xF5\x89K\xC6=\0\xC2\xED\x9Dd\xE3Z\rm\xE9Kef\x94X\x99d\xA2R\x95~Fs\xA9\xFB\x1D/\x8BJ\x92\xE3\xF0\xA7\xBBeO\xDD\xB9NZ\x1Em\x7F\x7FI\x9F\xD1\xBE]\xD3\ns\xBFU\x84\xBF\x13}\xA5\xFD\xD7|\xC2\x1A\xEB\x95\xB9\xE3W\x88\x89K\xE0\x19(K\xD4\xFB\xEDm\xD6\x11\x8A\xC2\xCBm&\xBCK\xE4\xE4#\xF5Z:H\xF2\x87M\x8D\x02\xA3\x1B\xC4\xAC\xABO\xFEM\xCD$\x08J\x18x\xF71}\xEE\x84\r-N ^\x02\xEA\x9F\xC1\x16\x07\xC7.%\x05\xD2\x05\xB4\xD6B\xEB\xA1\xC4<\xEA\xD8\xDA\x15t\xE0\xE8\xA9:\xA8d+Q\xD5\xCAC\xF5!O\x1E\xD6\xEA\xBA\xF6(]\x83\xF4`\xB5o\xA9\xDDB8\x82\x16o\xDE\t\xA8\xF8\xEB%@f\xE6\xA0\xA4\xB4\xC0\x07!`\xC38j\x0BI\xE7_\x17#\xD6\xAB(\xAC\x9A (\xA0\xC7(f\xE2\x11\x1Dy\xD4\x81{\x88\xE1|\x82\x82!A\\5\x15\xB1\x8A&\xEF\x99\x83>\xE2M\xAAPe.\xA0\x1E\xF0!\xE3u'e\xB6\xCBMZ\x1E\xD3w\x08\xD9\xCDpxf_\x07\x11#\xA2\xC7\x8E\xCB\x98\xEA\xF3\xA3CKd:r\x12n\r>\xCDEQ\x12\xCB\xF3Q\x15a\xE8\xA0\xAC\xD7\x89\x01\xF1\xF2\xD0Z\xD7g&\xFD\x07~\x1B\x9C\xFD9C\x04j\x92\x95\xFA", - ); - /// 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\x01yW_5`\xE0\x1C\x80c\x85\"l\x81\x11a\0\xD2W\x80c\xB5P\x8A\xA9\x11a\0\x88W\x80c\xF1\x1D\\\xBC\x11a\0cW\x80c\xF1\x1D\\\xBC\x14a\x02\xB9W\x80c\xFAv&\xD4\x14a\x02\xC1W\x80c\xFA\xD0k\x8F\x14a\x02\xCEW__\xFD[\x80c\xB5P\x8A\xA9\x14a\x02\x91W\x80c\xBAAO\xA6\x14a\x02\x99W\x80c\xE2\x0C\x9Fq\x14a\x02\xB1W__\xFD[\x80c\x979\x0E\xD6\x11a\0\xB8W\x80c\x979\x0E\xD6\x14a\x02yW\x80c\xB0FO\xDC\x14a\x02\x81W\x80c\xB5+ X\x14a\x02\x89W__\xFD[\x80c\x85\"l\x81\x14a\x02OW\x80c\x91j\x17\xC6\x14a\x02dW__\xFD[\x80c>^<#\x11a\x012W\x80cf\xD9\xA9\xA0\x11a\x01\rW\x80cf\xD9\xA9\xA0\x14a\x02*W\x80cr\xE1\x11\xD2\x14a\x02?W\x80c\x80Q\xAC_\x14a\x02GW__\xFD[\x80c>^<#\x14a\x01\xFAW\x80c?r\x86\xF4\x14a\x02\x02W\x80cD\xBA\xDB\xB6\x14a\x02\nW__\xFD[\x80c\x1E\xD7\x83\x1C\x11a\x01bW\x80c\x1E\xD7\x83\x1C\x14a\x01\xC6W\x80c*\xDE8\x80\x14a\x01\xDBW\x80c9B_\x8F\x14a\x01\xF0W__\xFD[\x80c\x08\x13\x85*\x14a\x01}W\x80c\x1C\r\xA8\x1F\x14a\x01\xA6W[__\xFD[a\x01\x90a\x01\x8B6`\x04a%EV[a\x02\xE1V[`@Qa\x01\x9D\x91\x90a%\xFAV[`@Q\x80\x91\x03\x90\xF3[a\x01\xB9a\x01\xB46`\x04a%EV[a\x03,V[`@Qa\x01\x9D\x91\x90a&]V[a\x01\xCEa\x03\x9EV[`@Qa\x01\x9D\x91\x90a&oV[a\x01\xE3a\x04\x0BV[`@Qa\x01\x9D\x91\x90a'!V[a\x01\xF8a\x05TV[\0[a\x01\xCEa\x06\xB0V[a\x01\xCEa\x07\x1BV[a\x02\x1Da\x02\x186`\x04a%EV[a\x07\x86V[`@Qa\x01\x9D\x91\x90a'\xA5V[a\x022a\x07\xC9V[`@Qa\x01\x9D\x91\x90a(8V[a\x01\xF8a\tBV[a\x01\xF8a\r\xEBV[a\x02Wa\x11\xE5V[`@Qa\x01\x9D\x91\x90a(\xB6V[a\x02la\x12\xB0V[`@Qa\x01\x9D\x91\x90a(\xC8V[a\x01\xF8a\x13\xB3V[a\x02la\x17\xA0V[a\x01\xF8a\x18\xA3V[a\x02Wa\x19`V[a\x02\xA1a\x1A+V[`@Q\x90\x15\x15\x81R` \x01a\x01\x9DV[a\x01\xCEa\x1A\xFBV[a\x01\xF8a\x1BfV[`\x1FTa\x02\xA1\x90`\xFF\x16\x81V[a\x02\x1Da\x02\xDC6`\x04a%EV[a\x1DFV[``a\x03$\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1D\x89V[\x94\x93PPPPV[``_a\x03:\x85\x85\x85a\x02\xE1V[\x90P_[a\x03H\x85\x85a)yV[\x81\x10\x15a\x03\x95W\x82\x82\x82\x81Q\x81\x10a\x03bWa\x03ba)\x8CV[` \x02` \x01\x01Q`@Q` \x01a\x03{\x92\x91\x90a)\xD0V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x03>V[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x01W` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xD6W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x054W\x83\x82\x90_R` _ \x01\x80Ta\x04\xA9\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x04\xD5\x90a)\xE4V[\x80\x15a\x05 W\x80`\x1F\x10a\x04\xF7Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05 V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05\x03W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x04\x8CV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x04.V[PPPP\x90P\x90V[`@\x80Q\x80\x82\x01\x82R`\x1A\x81R\x7FInsufficient confirmations\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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`\t\x91sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x05\xD7\x91`\x04\x01a&]V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05\xEEW__\xFD[PZ\xF1\x15\x80\x15a\x06\0W=__>=_\xFD[PP`%T`\x1FT`@Q\x7F\x97B>\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16\x94Pc\x97B>\xB4\x93Pa\x06m\x92a\x01\0\x90\x92\x04\x90\x91\x16\x90\x85\x90`'\x90`-\x90`\x04\x01a+\xC2V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\x88W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xAC\x91\x90a,\x97V[PPV[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x01W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xD6WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x01W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xD6WPPPPP\x90P\x90V[``a\x03$\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1E\xEAV[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x08\x1C\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x08H\x90a)\xE4V[\x80\x15a\x08\x93W\x80`\x1F\x10a\x08jWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x08\x93V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x08vW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\t*W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x08\xD7W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07\xECV[`@\x80Q`\x80\x81\x01\x82R`-\x80T\x82R`.T` \x83\x01R\x82Q`\xA0\x81\x01\x84R`/\x80T_\x95\x85\x01\x92\x91\x90\x82\x90\x82\x90a\tz\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\t\xA6\x90a)\xE4V[\x80\x15a\t\xF1W\x80`\x1F\x10a\t\xC8Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\t\xF1V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t\xD4W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01T\x81R` \x01`\x02\x82\x01\x80Ta\n\x14\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n@\x90a)\xE4V[\x80\x15a\n\x8BW\x80`\x1F\x10a\nbWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\x8BV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\nnW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x03\x82\x01T\x81R` \x01`\x04\x82\x01\x80Ta\n\xAE\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n\xDA\x90a)\xE4V[\x80\x15a\x0B%W\x80`\x1F\x10a\n\xFCWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B%V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\x08W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP\x81R`@\x80Q`\x80\x81\x01\x90\x91R`\x07\x83\x01\x80T`\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\x82R`\x08\x84\x01\x80T` \x94\x85\x01\x94\x84\x01\x91\x90a\x0B\x82\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\xAE\x90a)\xE4V[\x80\x15a\x0B\xF9W\x80`\x1F\x10a\x0B\xD0Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\xF9V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xDCW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x02\x82\x01\x80Ta\x0C\x12\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C>\x90a)\xE4V[\x80\x15a\x0C\x89W\x80`\x1F\x10a\x0C`Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C\x89V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0ClW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x83RPP`\x03\x91\x90\x91\x01T`\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` \x91\x82\x01R\x91R`@\x80Qa\x01`\x81\x01\x90\x91Ra\x01@\x80\x82R\x93\x94P\x92\x91Pa0G\x90\x83\x019\x81`@\x01Q`\x80\x01\x81\x90RPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xF2\x8D\xCE\xB3`@Q\x80``\x01`@R\x80`?\x81R` \x01a2\xF6`?\x919`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\rU\x91\x90a&]V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\rlW__\xFD[PZ\xF1\x15\x80\x15a\r~W=__>=_\xFD[PP`%T`\x1FT`&T`@Q\x7F\x97B>\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x93\x84\x16\x95Pc\x97B>\xB4\x94Pa\x06m\x93a\x01\0\x90\x93\x04\x90\x92\x16\x91`'\x90\x87\x90`\x04\x01a-@V[`@\x80Q`\x80\x81\x01\x82R`-\x80T\x82R`.T` \x83\x01R\x82Q`\xA0\x81\x01\x84R`/\x80T_\x95\x85\x01\x92\x91\x90\x82\x90\x82\x90a\x0E#\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0EO\x90a)\xE4V[\x80\x15a\x0E\x9AW\x80`\x1F\x10a\x0EqWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0E\x9AV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0E}W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01T\x81R` \x01`\x02\x82\x01\x80Ta\x0E\xBD\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0E\xE9\x90a)\xE4V[\x80\x15a\x0F4W\x80`\x1F\x10a\x0F\x0BWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F4V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\x17W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x03\x82\x01T\x81R` \x01`\x04\x82\x01\x80Ta\x0FW\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F\x83\x90a)\xE4V[\x80\x15a\x0F\xCEW\x80`\x1F\x10a\x0F\xA5Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F\xCEV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\xB1W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP\x81R`@\x80Q`\x80\x81\x01\x90\x91R`\x07\x83\x01\x80T`\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\x82R`\x08\x84\x01\x80T` \x94\x85\x01\x94\x84\x01\x91\x90a\x10+\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x10W\x90a)\xE4V[\x80\x15a\x10\xA2W\x80`\x1F\x10a\x10yWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x10\xA2V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x10\x85W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x02\x82\x01\x80Ta\x10\xBB\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x10\xE7\x90a)\xE4V[\x80\x15a\x112W\x80`\x1F\x10a\x11\tWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x112V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x11\x15W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x83RPP`\x03\x91\x90\x91\x01T`\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` \x91\x82\x01R\x91R`@\x80Qa\x01`\x81\x01\x90\x91Ra\x01@\x80\x82R\x93\x94P\x92\x91Pa1\x87\x90\x83\x019`@\x80\x83\x01Q\x91\x90\x91R\x80Q`\x80\x81\x01\x90\x91R`D\x80\x82Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a0\x03` \x83\x019`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\rU\x91\x90a&]V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW\x83\x82\x90_R` _ \x01\x80Ta\x12%\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x12Q\x90a)\xE4V[\x80\x15a\x12\x9CW\x80`\x1F\x10a\x12sWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x12\x9CV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x12\x7FW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x12\x08V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x13\x9BW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x13HW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x12\xD3V[`@\x80Q`\x80\x81\x01\x82R`-\x80T\x82R`.T` \x83\x01R\x82Q`\xA0\x81\x01\x84R`/\x80T_\x95\x85\x01\x92\x91\x90\x82\x90\x82\x90a\x13\xEB\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x14\x17\x90a)\xE4V[\x80\x15a\x14bW\x80`\x1F\x10a\x149Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x14bV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x14EW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01T\x81R` \x01`\x02\x82\x01\x80Ta\x14\x85\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x14\xB1\x90a)\xE4V[\x80\x15a\x14\xFCW\x80`\x1F\x10a\x14\xD3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x14\xFCV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x14\xDFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x03\x82\x01T\x81R` \x01`\x04\x82\x01\x80Ta\x15\x1F\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x15K\x90a)\xE4V[\x80\x15a\x15\x96W\x80`\x1F\x10a\x15mWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x15\x96V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15yW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP\x81R`@\x80Q`\x80\x81\x01\x90\x91R`\x07\x83\x01\x80T`\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\x82R`\x08\x84\x01\x80T` \x94\x85\x01\x94\x84\x01\x91\x90a\x15\xF3\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x16\x1F\x90a)\xE4V[\x80\x15a\x16jW\x80`\x1F\x10a\x16AWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x16jV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x16MW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x02\x82\x01\x80Ta\x16\x83\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x16\xAF\x90a)\xE4V[\x80\x15a\x16\xFAW\x80`\x1F\x10a\x16\xD1Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x16\xFAV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x16\xDDW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x83RPP`\x03\x91\x90\x91\x01T`\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` \x91\x82\x01R\x91R`@\x80Q\x80\x82\x01\x82R`\x01\x81R_\x81\x84\x01R\x84\x82\x01QR\x80Q``\x81\x01\x90\x91R`/\x80\x82R\x93\x94Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x93c\xF2\x8D\xCE\xB3\x93P\x90\x91a2\xC7\x90\x83\x019`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\rU\x91\x90a&]V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x18\x8BW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x188W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x17\xC3V[`%T`\x1FT`&T`@Q\x7F\x97B>\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_\x93s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16\x93c\x97B>\xB4\x93a\x19\x10\x93a\x01\0\x90\x92\x04\x90\x92\x16\x91\x90`'\x90`-\x90`\x04\x01a+\xC2V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x19+W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x19O\x91\x90a,\x97V[\x90Pa\x19]\x81`,Ta 8V[PV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x05KW\x83\x82\x90_R` _ \x01\x80Ta\x19\xA0\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x19\xCC\x90a)\xE4V[\x80\x15a\x1A\x17W\x80`\x1F\x10a\x19\xEEWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x1A\x17V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x19\xFAW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x19\x83V[`\x08T_\x90`\xFF\x16\x15a\x1ABWP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1A\xD0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1A\xF4\x91\x90a,\x97V[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x04\x01W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03\xD6WPPPPP\x90P\x90V[`\x1FT`@Q\x7F\xF5\x8D\xB0o\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R_`\x04\x82\x01\x81\x90R`$\x82\x01Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90c\xF5\x8D\xB0o\x90`D\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1B\xD9W__\xFD[PZ\xF1\x15\x80\x15a\x1B\xEBW=__>=_\xFD[PP`@\x80Q\x80\x82\x01\x82R`\x1B\x81R\x7FGCD does not confirm header\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x93Pc\xF2\x8D\xCE\xB3\x92Pa\x1Cp\x91\x90`\x04\x01a&]V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1C\x87W__\xFD[PZ\xF1\x15\x80\x15a\x1C\x99W=__>=_\xFD[PP`%T`\x1FT`&T`@Q\x7F\x97B>\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x93\x84\x16\x95Pc\x97B>\xB4\x94Pa\x1D\x07\x93a\x01\0\x90\x93\x04\x90\x92\x16\x91`'\x90`-\x90`\x04\x01a+\xC2V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1D\"W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x19]\x91\x90a,\x97V[``a\x03$\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa \xBBV[``a\x1D\x95\x84\x84a)yV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xADWa\x1D\xADa$\xC0V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x1D\xE0W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x1D\xCBW\x90P[P\x90P\x83[\x83\x81\x10\x15a\x1E\xE1Wa\x1E\xB3\x86a\x1D\xFA\x83a\"\tV[\x85`@Q` \x01a\x1E\r\x93\x92\x91\x90a.&V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x1E)\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x1EU\x90a)\xE4V[\x80\x15a\x1E\xA0W\x80`\x1F\x10a\x1EwWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x1E\xA0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x1E\x83W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa#:\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x1E\xBE\x87\x84a)yV[\x81Q\x81\x10a\x1E\xCEWa\x1E\xCEa)\x8CV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x1D\xE5V[P\x94\x93PPPPV[``a\x1E\xF6\x84\x84a)yV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x0EWa\x1F\x0Ea$\xC0V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x1F7W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x1E\xE1Wa \n\x86a\x1FQ\x83a\"\tV[\x85`@Q` \x01a\x1Fd\x93\x92\x91\x90a.&V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x1F\x80\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x1F\xAC\x90a)\xE4V[\x80\x15a\x1F\xF7W\x80`\x1F\x10a\x1F\xCEWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x1F\xF7V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x1F\xDAW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa#\xD9\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a \x15\x87\x84a)yV[\x81Q\x81\x10a %Wa %a)\x8CV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x1F=_\xFD[PPPPPPV[``a \xC7\x84\x84a)yV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a \xDFWa \xDFa$\xC0V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a!\x08W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x1E\xE1Wa!\xDB\x86a!\"\x83a\"\tV[\x85`@Q` \x01a!5\x93\x92\x91\x90a.&V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta!Q\x90a)\xE4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta!}\x90a)\xE4V[\x80\x15a!\xC8W\x80`\x1F\x10a!\x9FWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a!\xC8V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a!\xABW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa$l\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a!\xE6\x87\x84a)yV[\x81Q\x81\x10a!\xF6Wa!\xF6a)\x8CV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a!\rV[``\x81_\x03a\"KWPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\"tW\x80a\"^\x81a.\xC3V[\x91Pa\"m\x90P`\n\x83a/'V[\x91Pa\"NV[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\"\x8EWa\"\x8Ea$\xC0V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\"\xB8W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x03$Wa\"\xCD`\x01\x83a)yV[\x91Pa\"\xDA`\n\x86a/:V[a\"\xE5\x90`0a/MV[`\xF8\x1B\x81\x83\x81Q\x81\x10a\"\xFAWa\"\xFAa)\x8CV[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa#3`\n\x86a/'V[\x94Pa\"\xBCV[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a#\x8F\x90\x86\x90\x86\x90`\x04\x01a/`V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a#\xA9W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra#\xD0\x91\x90\x81\x01\x90a/\x8DV[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a$-\x90\x86\x90\x86\x90`\x04\x01a/`V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a$HW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a#\xD0\x91\x90a,\x97V[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a$-\x90\x86\x90\x86\x90`\x04\x01a/`V[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a%\x16Wa%\x16a$\xC0V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a%7Wa%7a$\xC0V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a%WW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a%mW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a%}W__\xFD[\x805a%\x90a%\x8B\x82a%\x1EV[a$\xEDV[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a%\xA4W__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a&QW`?\x19\x87\x86\x03\x01\x84Ra&<\x85\x83Qa%\xCCV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a& V[P\x92\x96\x95PPPPPPV[` \x81R_a#\xD0` \x83\x01\x84a%\xCCV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a&\xBCW\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&\x88V[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a'\x15W`\x1F\x19\x85\x84\x03\x01\x88Ra&\xFF\x83\x83Qa%\xCCV[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a&\xE3V[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a&QW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra'\x8F`@\x87\x01\x82a&\xC7V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a'GV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a&\xBCW\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a'\xBEV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a(.W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a'\xEEV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a&QW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra(\x84`@\x88\x01\x82a%\xCCV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra(\x9F\x81\x83a'\xDCV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a(^V[` \x81R_a#\xD0` \x83\x01\x84a&\xC7V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a&QW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra)6`@\x87\x01\x82a'\xDCV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a(\xEEV[\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#\xD3Wa#\xD3a)LV[\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x03$a)\xDE\x83\x86a)\xB9V[\x84a)\xB9V[`\x01\x81\x81\x1C\x90\x82\x16\x80a)\xF8W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a*/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`\"`\x04R`$_\xFD[P\x91\x90PV[\x80T_\x90`\x01\x81\x81\x1C\x90\x82\x16\x80a*MW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a*\x84W\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[\x81\x86R` \x86\x01\x81\x80\x15a*\x9FW`\x01\x81\x14a*\xD3Wa*\xFFV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x85\x16\x82R\x83\x15\x15`\x05\x1B\x82\x01\x95Pa*\xFFV[_\x87\x81R` \x90 _[\x85\x81\x10\x15a*\xF9W\x81T\x84\x82\x01R`\x01\x90\x91\x01\x90` \x01a*\xDDV[\x83\x01\x96PP[PPPPP\x92\x91PPV[\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\x81T`\xE0\x1B\x16\x82R`\x80` \x83\x01R_a+K`\x80\x84\x01`\x01\x84\x01a*5V[\x83\x81\x03`@\x85\x01Ra+`\x81`\x02\x85\x01a*5V[\x90P\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`\x03\x84\x01T`\xE0\x1B\x16``\x85\x01R\x80\x91PP\x92\x91PPV[`@\x82R_a+\xAD`@\x84\x01\x83a+\nV[\x83\x81\x03` \x85\x01Ra\x03$\x81`\x04\x85\x01a*5V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x81R\x83` \x82\x01R`\x80`@\x82\x01R_a+\xF6`\x80\x83\x01\x85a+\x9BV[\x82\x81\x03``\x84\x01R\x83T\x81R`\x01\x84\x01T` \x82\x01R`\x80`@\x82\x01R`\xA0`\x80\x82\x01Ra,+a\x01 \x82\x01`\x02\x86\x01a*5V[`\x03\x85\x01T`\xA0\x83\x01R`\x7F\x19\x82\x82\x03\x01`\xC0\x83\x01Ra,N\x81`\x04\x87\x01a*5V[\x90P`\x05\x85\x01T`\xE0\x83\x01R`\x7F\x19\x82\x82\x03\x01a\x01\0\x83\x01Ra,t\x81`\x06\x87\x01a*5V[\x90P\x81\x81\x03``\x83\x01Ra,\x8B\x81`\x07\x87\x01a+\nV[\x98\x97PPPPPPPPV[_` \x82\x84\x03\x12\x15a,\xA7W__\xFD[PQ\x91\x90PV[\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\x81Q\x16\x82R_` \x82\x01Q`\x80` \x85\x01Ra,\xEE`\x80\x85\x01\x82a%\xCCV[\x90P`@\x83\x01Q\x84\x82\x03`@\x86\x01Ra-\x07\x82\x82a%\xCCV[\x91PP\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``\x84\x01Q\x16``\x85\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\x85\x16\x81R\x83` \x82\x01R`\x80`@\x82\x01R_a-t`\x80\x83\x01\x85a+\x9BV[\x82\x81\x03``\x84\x01R\x83Q\x81R` \x84\x01Q` \x82\x01R`@\x84\x01Q`\x80`@\x83\x01R\x80Q`\xA0`\x80\x84\x01Ra-\xADa\x01 \x84\x01\x82a%\xCCV[\x90P` \x82\x01Q`\xA0\x84\x01R`@\x82\x01Q`\x7F\x19\x84\x83\x03\x01`\xC0\x85\x01Ra-\xD4\x82\x82a%\xCCV[\x91PP``\x82\x01Q`\xE0\x84\x01R`\x80\x82\x01Q\x91P`\x7F\x19\x83\x82\x03\x01a\x01\0\x84\x01Ra-\xFF\x81\x83a%\xCCV[\x91PP``\x85\x01Q\x82\x82\x03``\x84\x01Ra.\x19\x82\x82a,\xAEV[\x99\x98PPPPPPPPPV[\x7F.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R_a.W`\x01\x83\x01\x86a)\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\x81Ra.\x87`\x01\x82\x01\x86a)\xB9V[\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\x81Ra.\xB9`\x02\x82\x01\x85a)\xB9V[\x96\x95PPPPPPV[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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.\xF3Wa.\xF3a)LV[P`\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`\x12`\x04R`$_\xFD[_\x82a/5Wa/5a.\xFAV[P\x04\x90V[_\x82a/HWa/Ha.\xFAV[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a#\xD3Wa#\xD3a)LV[`@\x81R_a/r`@\x83\x01\x85a%\xCCV[\x82\x81\x03` \x84\x01Ra/\x84\x81\x85a%\xCCV[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a/\x9DW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a/\xB3W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a/\xC3W__\xFD[\x80Qa/\xD1a%\x8B\x82a%\x1EV[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a/\xE5W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV\xFETx witness merkle proof is not valid for provided header and tx hash\xDC \xDA\xDE\xF4w\xFA\xAB(R\xF2\xF8\xAE\x0C\x82j\xA7\xE0\\M\xE0\xD3o\x0Ecc\x04)UH\x84\xC3q\xDAYt\xB6\xF3O\xA2\xC3Sg8\xF01\xB4\x9F4\xE0\xC9\xD0\x84\xD7(\x0F&!.9\0~\xBE\x9E\xA0\x87\x0C1'E\xB5\x81(\xA0\neW\x85\x1E\x98~\xCE\x02)M\x15o\0 3n\x15\x89(\xE8\x96B\x92d,lM\xC4i\xF3K{\xAC\xF2\xD8\xC4!\x15\xBA\xB6\xAF\xC9\x06\x7F.\xD3\x0E\x87Ir\x9Bc\xE0\x88\x9E >\xE5\x8E5Y\x03\xC1\xE7\x1Fx\xC0\x08\xDFl5\x97\xB2\xCCf\xD0\xB8\xAA\xE1\xA4\xA3<\xAAwT\x98\xE51\xCF\xB6\xAFX\xE8}\xB9\x9E\x0FSm\xD2&\xD1\x8FC\xE3\x86AH\xBA[\x7F\xAC\xA5\xC7u\xF1\x0B\xC8\x10\xC6\x02\xE1\xAF!\x95\xA3Ew\x97i!\xCE\0\x9AM\xDC\n\x07\xF6\x05\xC9k\x0F_\xCFX\x081\xEB\xBE\x01\xA3\x1F\xA2\x9B\xDE\x88F\t\xD2\x86\xDC\xCF\xA5\xBA\x8EU\x8C\xE3\x12[\xD4\xC3\xA1\x9E\x88\x8C\xF2hR(b\x02\xD2\xA7\xD3\x02\xC7^\x0F\xF5\xCA\x8F\xE7)\x9F\xB0\xD9\xD1\x13+\xF2\xC5l.;s\xDFy\x92\x86\x19=`\xC1\t\xB1\x87\xD6Eq\xEF\xBA\xA8\x04{\xE8X!\xF8\xE6~\x0E\x85\xF2\xF5\x89K\xC6=\0\xC2\xED\x9De\xE3Z\rm\xE9Kef\x94X\x99d\xA2R\x95~Fs\xA9\xFB\x1D/\x8BJ\x92\xE3\xF0\xA7\xBBeO\xDD\xB9NZ\x1Em\x7F\x7FI\x9F\xD1\xBE]\xD3\ns\xBFU\x84\xBF\x13}\xA5\xFD\xD7|\xC2\x1A\xEB\x95\xB9\xE3W\x88\x89K\xE0\x19(K\xD4\xFB\xEDm\xD6\x11\x8A\xC2\xCBm&\xBCK\xE4\xE4#\xF5Z:H\xF2\x87M\x8D\x02\xA3\x1B\xC4\xAC\xABO\xFEM\xCD$\x08J\x18x\xF71}\xEE\x84\r-N ^\x02\xEA\x9F\xC1\x16\x07\xC7.%\x05\xD2\x05\xB4\xD6B\xEB\xA1\xC4<\xEA\xD8\xDA\x15t\xE0\xE8\xA9:\xA8d+Q\xD5\xCAC\xF5!O\x1E\xD6\xEA\xBA\xF6(]\x83\xF4`\xB5o\xA9\xDDB8\x82\x16o\xDE\t\xA8\xF8\xEB%@f\xE6\xA0\xA4\xB4\xC0\x07!`\xC38j\x0BI\xE7_\x17#\xD6\xAB(\xAC\x9A (\xA0\xC7(f\xE2\x11\x1Dy\xD4\x81{\x88\xE1|\x82\x82!A\\5\x15\xB1\x8A&\xEF\x99\x83>\xE2M\xAAPe.\xA0\x1E\xF0!\xE3u'e\xB6\xCBMZ\x1E\xD3w\x08\xD9\xCDpxf_\x07\x11#\xA2\xC7\x8E\xCB\x98\xEA\xF3\xA3CKd:r\x12n\r>\xCDEQ\x12\xCB\xF3Q\x15a\xE8\xA0\xAC\xD7\x89\x01\xF1\xF2\xD0Z\xD7g&\xFD\x07~\x1B\x9C\xFD9C\x04j\x92\x95\xFBTx not on same level of merkle tree as coinbaseCoinbase merkle proof is not valid for provided header and hash\xA2dipfsX\"\x12 \xC60\x1D\x86\x1F\r\xCE\xB5\xD13a\xF4r,\xAC7\xD9s)$%\x8C\x06\xF4\x85K\xF0\xFD\r=\xCB4dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. -```solidity -event log(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getBlockHeights(string,uint256,uint256)` and selector `0xfad06b8f`. -```solidity -function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getBlockHeightsCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getBlockHeights(string,uint256,uint256)`](getBlockHeightsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getBlockHeightsReturn { - #[allow(missing_docs)] - pub elements: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getBlockHeightsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - #[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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getBlockHeightsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getBlockHeightsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getBlockHeights(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [250u8, 208u8, 107u8, 143u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getDigestLes(string,uint256,uint256)` and selector `0x44badbb6`. -```solidity -function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getDigestLesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getDigestLes(string,uint256,uint256)`](getDigestLesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getDigestLesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getDigestLesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getDigestLesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getDigestLesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array< - alloy::sol_types::sol_data::FixedBytes<32>, - >, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getDigestLes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [68u8, 186u8, 219u8, 182u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaderHexes(string,uint256,uint256)` and selector `0x0813852a`. -```solidity -function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaderHexes(string,uint256,uint256)`](getHeaderHexesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeaderHexesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getHeaderHexesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getHeaderHexesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Bytes, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaderHexes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [8u8, 19u8, 133u8, 42u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaders(string,uint256,uint256)` and selector `0x1c0da81f`. -```solidity -function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaders(string,uint256,uint256)`](getHeadersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersReturn { - #[allow(missing_docs)] - pub headers: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersReturn) -> Self { - (value.headers,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { headers: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getHeadersCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Bytes; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaders(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [28u8, 13u8, 168u8, 31u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testGCDDoesntConfirmHeader()` and selector `0xf11d5cbc`. -```solidity -function testGCDDoesntConfirmHeader() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testGCDDoesntConfirmHeaderCall; - ///Container type for the return parameters of the [`testGCDDoesntConfirmHeader()`](testGCDDoesntConfirmHeaderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testGCDDoesntConfirmHeaderReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testGCDDoesntConfirmHeaderCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testGCDDoesntConfirmHeaderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testGCDDoesntConfirmHeaderReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testGCDDoesntConfirmHeaderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testGCDDoesntConfirmHeaderReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testGCDDoesntConfirmHeaderCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testGCDDoesntConfirmHeaderReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testGCDDoesntConfirmHeader()"; - const SELECTOR: [u8; 4] = [241u8, 29u8, 92u8, 188u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testGCDDoesntConfirmHeaderReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testInconsistentProofLengths()` and selector `0x97390ed6`. -```solidity -function testInconsistentProofLengths() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testInconsistentProofLengthsCall; - ///Container type for the return parameters of the [`testInconsistentProofLengths()`](testInconsistentProofLengthsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testInconsistentProofLengthsReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testInconsistentProofLengthsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testInconsistentProofLengthsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testInconsistentProofLengthsReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testInconsistentProofLengthsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testInconsistentProofLengthsReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testInconsistentProofLengthsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testInconsistentProofLengthsReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testInconsistentProofLengths()"; - const SELECTOR: [u8; 4] = [151u8, 57u8, 14u8, 214u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testInconsistentProofLengthsReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testIncorrectCoinbaseProofSupplied()` and selector `0x72e111d2`. -```solidity -function testIncorrectCoinbaseProofSupplied() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIncorrectCoinbaseProofSuppliedCall; - ///Container type for the return parameters of the [`testIncorrectCoinbaseProofSupplied()`](testIncorrectCoinbaseProofSuppliedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIncorrectCoinbaseProofSuppliedReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIncorrectCoinbaseProofSuppliedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIncorrectCoinbaseProofSuppliedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIncorrectCoinbaseProofSuppliedReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIncorrectCoinbaseProofSuppliedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testIncorrectCoinbaseProofSuppliedReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testIncorrectCoinbaseProofSuppliedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testIncorrectCoinbaseProofSuppliedReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testIncorrectCoinbaseProofSupplied()"; - const SELECTOR: [u8; 4] = [114u8, 225u8, 17u8, 210u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testIncorrectCoinbaseProofSuppliedReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testIncorrectPaymentProofSupplied()` and selector `0x8051ac5f`. -```solidity -function testIncorrectPaymentProofSupplied() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIncorrectPaymentProofSuppliedCall; - ///Container type for the return parameters of the [`testIncorrectPaymentProofSupplied()`](testIncorrectPaymentProofSuppliedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIncorrectPaymentProofSuppliedReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIncorrectPaymentProofSuppliedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIncorrectPaymentProofSuppliedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIncorrectPaymentProofSuppliedReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIncorrectPaymentProofSuppliedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testIncorrectPaymentProofSuppliedReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testIncorrectPaymentProofSuppliedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testIncorrectPaymentProofSuppliedReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testIncorrectPaymentProofSupplied()"; - const SELECTOR: [u8; 4] = [128u8, 81u8, 172u8, 95u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testIncorrectPaymentProofSuppliedReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testInsufficientConfirmations()` and selector `0x39425f8f`. -```solidity -function testInsufficientConfirmations() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testInsufficientConfirmationsCall; - ///Container type for the return parameters of the [`testInsufficientConfirmations()`](testInsufficientConfirmationsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testInsufficientConfirmationsReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testInsufficientConfirmationsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testInsufficientConfirmationsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testInsufficientConfirmationsReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testInsufficientConfirmationsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testInsufficientConfirmationsReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testInsufficientConfirmationsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testInsufficientConfirmationsReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testInsufficientConfirmations()"; - const SELECTOR: [u8; 4] = [57u8, 66u8, 95u8, 143u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testInsufficientConfirmationsReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testSuccessfullyVerify()` and selector `0xb52b2058`. -```solidity -function testSuccessfullyVerify() external view; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testSuccessfullyVerifyCall; - ///Container type for the return parameters of the [`testSuccessfullyVerify()`](testSuccessfullyVerifyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testSuccessfullyVerifyReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testSuccessfullyVerifyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testSuccessfullyVerifyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testSuccessfullyVerifyReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testSuccessfullyVerifyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testSuccessfullyVerifyReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testSuccessfullyVerifyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testSuccessfullyVerifyReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testSuccessfullyVerify()"; - const SELECTOR: [u8; 4] = [181u8, 43u8, 32u8, 88u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testSuccessfullyVerifyReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`FullRelayWithVerifyThroughWitnessTxTest`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum FullRelayWithVerifyThroughWitnessTxTestCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - getBlockHeights(getBlockHeightsCall), - #[allow(missing_docs)] - getDigestLes(getDigestLesCall), - #[allow(missing_docs)] - getHeaderHexes(getHeaderHexesCall), - #[allow(missing_docs)] - getHeaders(getHeadersCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - testGCDDoesntConfirmHeader(testGCDDoesntConfirmHeaderCall), - #[allow(missing_docs)] - testInconsistentProofLengths(testInconsistentProofLengthsCall), - #[allow(missing_docs)] - testIncorrectCoinbaseProofSupplied(testIncorrectCoinbaseProofSuppliedCall), - #[allow(missing_docs)] - testIncorrectPaymentProofSupplied(testIncorrectPaymentProofSuppliedCall), - #[allow(missing_docs)] - testInsufficientConfirmations(testInsufficientConfirmationsCall), - #[allow(missing_docs)] - testSuccessfullyVerify(testSuccessfullyVerifyCall), - } - #[automatically_derived] - impl FullRelayWithVerifyThroughWitnessTxTestCalls { - /// 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, 19u8, 133u8, 42u8], - [28u8, 13u8, 168u8, 31u8], - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [57u8, 66u8, 95u8, 143u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [68u8, 186u8, 219u8, 182u8], - [102u8, 217u8, 169u8, 160u8], - [114u8, 225u8, 17u8, 210u8], - [128u8, 81u8, 172u8, 95u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [151u8, 57u8, 14u8, 214u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 43u8, 32u8, 88u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [226u8, 12u8, 159u8, 113u8], - [241u8, 29u8, 92u8, 188u8], - [250u8, 118u8, 38u8, 212u8], - [250u8, 208u8, 107u8, 143u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for FullRelayWithVerifyThroughWitnessTxTestCalls { - const NAME: &'static str = "FullRelayWithVerifyThroughWitnessTxTestCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 22usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::getBlockHeights(_) => { - ::SELECTOR - } - Self::getDigestLes(_) => { - ::SELECTOR - } - Self::getHeaderHexes(_) => { - ::SELECTOR - } - Self::getHeaders(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::testGCDDoesntConfirmHeader(_) => { - ::SELECTOR - } - Self::testInconsistentProofLengths(_) => { - ::SELECTOR - } - Self::testIncorrectCoinbaseProofSupplied(_) => { - ::SELECTOR - } - Self::testIncorrectPaymentProofSupplied(_) => { - ::SELECTOR - } - Self::testInsufficientConfirmations(_) => { - ::SELECTOR - } - Self::testSuccessfullyVerify(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - >] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::getHeaderHexes, - ) - } - getHeaderHexes - }, - { - fn getHeaders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::getHeaders, - ) - } - getHeaders - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::excludeSenders, - ) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::targetInterfaces, - ) - } - targetInterfaces - }, - { - fn testInsufficientConfirmations( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::testInsufficientConfirmations, - ) - } - testInsufficientConfirmations - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::targetSenders, - ) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::targetContracts, - ) - } - targetContracts - }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::getDigestLes, - ) - } - getDigestLes - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn testIncorrectCoinbaseProofSupplied( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::testIncorrectCoinbaseProofSupplied, - ) - } - testIncorrectCoinbaseProofSupplied - }, - { - fn testIncorrectPaymentProofSupplied( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::testIncorrectPaymentProofSupplied, - ) - } - testIncorrectPaymentProofSupplied - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::targetArtifacts, - ) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::targetSelectors, - ) - } - targetSelectors - }, - { - fn testInconsistentProofLengths( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::testInconsistentProofLengths, - ) - } - testInconsistentProofLengths - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::excludeSelectors, - ) - } - excludeSelectors - }, - { - fn testSuccessfullyVerify( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::testSuccessfullyVerify, - ) - } - testSuccessfullyVerify - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::excludeArtifacts, - ) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw(data) - .map(FullRelayWithVerifyThroughWitnessTxTestCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::excludeContracts, - ) - } - excludeContracts - }, - { - fn testGCDDoesntConfirmHeader( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::testGCDDoesntConfirmHeader, - ) - } - testGCDDoesntConfirmHeader - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw(data) - .map(FullRelayWithVerifyThroughWitnessTxTestCalls::IS_TEST) - } - IS_TEST - }, - { - fn getBlockHeights( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::getBlockHeights, - ) - } - getBlockHeights - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - >] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::getHeaderHexes, - ) - } - getHeaderHexes - }, - { - fn getHeaders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::getHeaders, - ) - } - getHeaders - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::excludeSenders, - ) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::targetInterfaces, - ) - } - targetInterfaces - }, - { - fn testInsufficientConfirmations( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::testInsufficientConfirmations, - ) - } - testInsufficientConfirmations - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::targetSenders, - ) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::targetContracts, - ) - } - targetContracts - }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::getDigestLes, - ) - } - getDigestLes - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn testIncorrectCoinbaseProofSupplied( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::testIncorrectCoinbaseProofSupplied, - ) - } - testIncorrectCoinbaseProofSupplied - }, - { - fn testIncorrectPaymentProofSupplied( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::testIncorrectPaymentProofSupplied, - ) - } - testIncorrectPaymentProofSupplied - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::targetArtifacts, - ) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::targetSelectors, - ) - } - targetSelectors - }, - { - fn testInconsistentProofLengths( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::testInconsistentProofLengths, - ) - } - testInconsistentProofLengths - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::excludeSelectors, - ) - } - excludeSelectors - }, - { - fn testSuccessfullyVerify( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::testSuccessfullyVerify, - ) - } - testSuccessfullyVerify - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::excludeArtifacts, - ) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayWithVerifyThroughWitnessTxTestCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::excludeContracts, - ) - } - excludeContracts - }, - { - fn testGCDDoesntConfirmHeader( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::testGCDDoesntConfirmHeader, - ) - } - testGCDDoesntConfirmHeader - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayWithVerifyThroughWitnessTxTestCalls::IS_TEST) - } - IS_TEST - }, - { - fn getBlockHeights( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayWithVerifyThroughWitnessTxTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayWithVerifyThroughWitnessTxTestCalls::getBlockHeights, - ) - } - getBlockHeights - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::getBlockHeights(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getDigestLes(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getHeaders(inner) => { - ::abi_encoded_size(inner) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testGCDDoesntConfirmHeader(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testInconsistentProofLengths(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testIncorrectCoinbaseProofSupplied(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testIncorrectPaymentProofSupplied(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testInsufficientConfirmations(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testSuccessfullyVerify(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::getBlockHeights(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getDigestLes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testGCDDoesntConfirmHeader(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testInconsistentProofLengths(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testIncorrectCoinbaseProofSupplied(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testIncorrectPaymentProofSupplied(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testInsufficientConfirmations(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testSuccessfullyVerify(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`FullRelayWithVerifyThroughWitnessTxTest`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum FullRelayWithVerifyThroughWitnessTxTestEvents { - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl FullRelayWithVerifyThroughWitnessTxTestEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface - for FullRelayWithVerifyThroughWitnessTxTestEvents { - const NAME: &'static str = "FullRelayWithVerifyThroughWitnessTxTestEvents"; - const COUNT: usize = 22usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 FullRelayWithVerifyThroughWitnessTxTestEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`FullRelayWithVerifyThroughWitnessTxTest`](self) contract instance. - -See the [wrapper's documentation](`FullRelayWithVerifyThroughWitnessTxTestInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> FullRelayWithVerifyThroughWitnessTxTestInstance { - FullRelayWithVerifyThroughWitnessTxTestInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result< - FullRelayWithVerifyThroughWitnessTxTestInstance, - >, - > { - FullRelayWithVerifyThroughWitnessTxTestInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - FullRelayWithVerifyThroughWitnessTxTestInstance::::deploy_builder(provider) - } - /**A [`FullRelayWithVerifyThroughWitnessTxTest`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`FullRelayWithVerifyThroughWitnessTxTest`](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 FullRelayWithVerifyThroughWitnessTxTestInstance< - P, - N = alloy_contract::private::Ethereum, - > { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug - for FullRelayWithVerifyThroughWitnessTxTestInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("FullRelayWithVerifyThroughWitnessTxTestInstance") - .field(&self.address) - .finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayWithVerifyThroughWitnessTxTestInstance { - /**Creates a new wrapper around an on-chain [`FullRelayWithVerifyThroughWitnessTxTest`](self) contract instance. - -See the [wrapper's documentation](`FullRelayWithVerifyThroughWitnessTxTestInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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< - FullRelayWithVerifyThroughWitnessTxTestInstance, - > { - 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 { - 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, - > FullRelayWithVerifyThroughWitnessTxTestInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider( - self, - ) -> FullRelayWithVerifyThroughWitnessTxTestInstance { - FullRelayWithVerifyThroughWitnessTxTestInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayWithVerifyThroughWitnessTxTestInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`getBlockHeights`] function. - pub fn getBlockHeights( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getBlockHeightsCall, N> { - self.call_builder( - &getBlockHeightsCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getDigestLes`] function. - pub fn getDigestLes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getDigestLesCall, N> { - self.call_builder( - &getDigestLesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaderHexes`] function. - pub fn getHeaderHexes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeaderHexesCall, N> { - self.call_builder( - &getHeaderHexesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaders`] function. - pub fn getHeaders( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeadersCall, N> { - self.call_builder( - &getHeadersCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`testGCDDoesntConfirmHeader`] function. - pub fn testGCDDoesntConfirmHeader( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testGCDDoesntConfirmHeaderCall, N> { - self.call_builder(&testGCDDoesntConfirmHeaderCall) - } - ///Creates a new call builder for the [`testInconsistentProofLengths`] function. - pub fn testInconsistentProofLengths( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testInconsistentProofLengthsCall, N> { - self.call_builder(&testInconsistentProofLengthsCall) - } - ///Creates a new call builder for the [`testIncorrectCoinbaseProofSupplied`] function. - pub fn testIncorrectCoinbaseProofSupplied( - &self, - ) -> alloy_contract::SolCallBuilder< - &P, - testIncorrectCoinbaseProofSuppliedCall, - N, - > { - self.call_builder(&testIncorrectCoinbaseProofSuppliedCall) - } - ///Creates a new call builder for the [`testIncorrectPaymentProofSupplied`] function. - pub fn testIncorrectPaymentProofSupplied( - &self, - ) -> alloy_contract::SolCallBuilder< - &P, - testIncorrectPaymentProofSuppliedCall, - N, - > { - self.call_builder(&testIncorrectPaymentProofSuppliedCall) - } - ///Creates a new call builder for the [`testInsufficientConfirmations`] function. - pub fn testInsufficientConfirmations( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testInsufficientConfirmationsCall, N> { - self.call_builder(&testInsufficientConfirmationsCall) - } - ///Creates a new call builder for the [`testSuccessfullyVerify`] function. - pub fn testSuccessfullyVerify( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testSuccessfullyVerifyCall, N> { - self.call_builder(&testSuccessfullyVerifyCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FullRelayWithVerifyThroughWitnessTxTestInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/hybrid_btc_strategy.rs b/crates/bindings/src/hybrid_btc_strategy.rs new file mode 100644 index 000000000..31267e787 --- /dev/null +++ b/crates/bindings/src/hybrid_btc_strategy.rs @@ -0,0 +1,1788 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface HybridBTCStrategy { + struct StrategySlippageArgs { + uint256 amountOutMin; + } + + event TokenOutput(address tokenReceived, uint256 amountOut); + + constructor(address _boringVault, address _teller); + + function boringVault() external view returns (address); + function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; + function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; + function teller() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_boringVault", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "_teller", + "type": "address", + "internalType": "contract ITeller" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "boringVault", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IERC20" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "handleGatewayMessage", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "message", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessageWithSlippageArgs", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "args", + "type": "tuple", + "internalType": "struct StrategySlippageArgs", + "components": [ + { + "name": "amountOutMin", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "teller", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract ITeller" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "TokenOutput", + "inputs": [ + { + "name": "tokenReceived", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "amountOut", + "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 HybridBTCStrategy { + use super::*; + use alloy::sol_types as 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\r\xD28\x03\x80a\r\xD2\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\xF5a\0\xDD_9_\x81\x81`h\x01Ra\x02\x87\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xC1\x01R\x81\x81a\x03\x0F\x01R\x81\x81a\x03}\x01Ra\x04\xB8\x01Ra\x0C\xF5_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cPcL\x0E\x14a\0NW\x80cW\xED\xABN\x14a\0cW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xF3\xB9w\x84\x14a\0\xC6W[__\xFD[a\0aa\0\\6`\x04a\n{V[a\0\xEDV[\0[a\0\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\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\0aa\0\xC16`\x04a\x0B=V[a\x01\x17V[a\0\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\x81V[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\xC1V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x16V[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\xDAV[`@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\x83\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B\xE5V[\x82Q`@Q\x7F\x0E\xFEj\x8B\0\0\0\0\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`$\x82\x01\x88\x90R`D\x82\x01\x92\x90\x92R\x91\x92P_\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\x90\x91\x16\x90c\x0E\xFEj\x8B\x90`d\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02\xCFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xF3\x91\x90a\x0B\xE5V[\x90Pa\x036s\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\x83a\x06\xD5V[`@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_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\xC4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xE8\x91\x90a\x0B\xE5V[\x90P\x82\x81\x11a\x04>W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x04I\x84\x83a\x0C)V[\x85Q\x90\x91P\x81\x10\x15a\x04\x9DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x045V[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\xD4\x90\x85\x90\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\x90`\x84\x01[`@\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\x070V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06NW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06r\x91\x90a\x0B\xE5V[a\x06|\x91\x90a\x0CBV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\xD4\x90\x85\x90\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\x90`d\x01a\x05pV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07+\x90\x84\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\x90`d\x01a\x05pV[PPPV[_a\x07\x91\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\x08!\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07+W\x80\x80` \x01\x90Q\x81\x01\x90a\x07\xAF\x91\x90a\x0CUV[a\x07+W`@QbF\x1B\xCD`\xE5\x1B\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\x045V[``a\x08/\x84\x84_\x85a\x089V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\xB1W`@QbF\x1B\xCD`\xE5\x1B\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\x045V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\x15W`@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\x045V[__\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\t=\x91\x90a\x0CtV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\twW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t|V[``\x91P[P\x91P\x91Pa\t\x8C\x82\x82\x86a\t\x97V[\x97\x96PPPPPPPV[``\x83\x15a\t\xA6WP\x81a\x082V[\x82Q\x15a\t\xB6W\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x045\x91\x90a\x0C\x8AV[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\t\xF1W__\xFD[PV[\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\nDWa\nDa\t\xF4V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\nsWa\nsa\t\xF4V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\n\x8EW__\xFD[\x845a\n\x99\x81a\t\xD0V[\x93P` \x85\x015\x92P`@\x85\x015a\n\xB0\x81a\t\xD0V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xCBW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\xDBW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xF5Wa\n\xF5a\t\xF4V[a\x0B\x08` `\x1F\x19`\x1F\x84\x01\x16\x01a\nJV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0B\x1CW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0BQW__\xFD[\x855a\x0B\\\x81a\t\xD0V[\x94P` \x86\x015\x93P`@\x86\x015a\x0Bs\x81a\t\xD0V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0B\xA4W__\xFD[Pa\x0B\xADa\n!V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\xD2W__\xFD[Pa\x0B\xDBa\n!V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xF5W__\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[\x81\x81\x03\x81\x81\x11\x15a\x0C=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B\xE5V[\x82Q`@Q\x7F\x0E\xFEj\x8B\0\0\0\0\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`$\x82\x01\x88\x90R`D\x82\x01\x92\x90\x92R\x91\x92P_\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\x90\x91\x16\x90c\x0E\xFEj\x8B\x90`d\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02\xCFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xF3\x91\x90a\x0B\xE5V[\x90Pa\x036s\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\x83a\x06\xD5V[`@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_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\xC4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xE8\x91\x90a\x0B\xE5V[\x90P\x82\x81\x11a\x04>W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x04I\x84\x83a\x0C)V[\x85Q\x90\x91P\x81\x10\x15a\x04\x9DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x045V[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\xD4\x90\x85\x90\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\x90`\x84\x01[`@\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\x070V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06NW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06r\x91\x90a\x0B\xE5V[a\x06|\x91\x90a\x0CBV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\xD4\x90\x85\x90\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\x90`d\x01a\x05pV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07+\x90\x84\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\x90`d\x01a\x05pV[PPPV[_a\x07\x91\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\x08!\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07+W\x80\x80` \x01\x90Q\x81\x01\x90a\x07\xAF\x91\x90a\x0CUV[a\x07+W`@QbF\x1B\xCD`\xE5\x1B\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\x045V[``a\x08/\x84\x84_\x85a\x089V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\xB1W`@QbF\x1B\xCD`\xE5\x1B\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\x045V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\x15W`@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\x045V[__\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\t=\x91\x90a\x0CtV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\twW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t|V[``\x91P[P\x91P\x91Pa\t\x8C\x82\x82\x86a\t\x97V[\x97\x96PPPPPPPV[``\x83\x15a\t\xA6WP\x81a\x082V[\x82Q\x15a\t\xB6W\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x045\x91\x90a\x0C\x8AV[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\t\xF1W__\xFD[PV[\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\nDWa\nDa\t\xF4V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\nsWa\nsa\t\xF4V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\n\x8EW__\xFD[\x845a\n\x99\x81a\t\xD0V[\x93P` \x85\x015\x92P`@\x85\x015a\n\xB0\x81a\t\xD0V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xCBW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\xDBW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xF5Wa\n\xF5a\t\xF4V[a\x0B\x08` `\x1F\x19`\x1F\x84\x01\x16\x01a\nJV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0B\x1CW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0BQW__\xFD[\x855a\x0B\\\x81a\t\xD0V[\x94P` \x86\x015\x93P`@\x86\x015a\x0Bs\x81a\t\xD0V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0B\xA4W__\xFD[Pa\x0B\xADa\n!V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\xD2W__\xFD[Pa\x0B\xDBa\n!V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xF5W__\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[\x81\x81\x03\x81\x81\x11\x15a\x0C = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: StrategySlippageArgs) -> Self { + (value.amountOutMin,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for StrategySlippageArgs { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { amountOutMin: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for StrategySlippageArgs { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for StrategySlippageArgs { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for StrategySlippageArgs { + const NAME: &'static str = "StrategySlippageArgs"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "StrategySlippageArgs(uint256 amountOutMin)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) + .0 + .to_vec() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for StrategySlippageArgs { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.amountOutMin, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.amountOutMin, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. +```solidity +event TokenOutput(address tokenReceived, uint256 amountOut); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct TokenOutput { + #[allow(missing_docs)] + pub tokenReceived: alloy::sol_types::private::Address, + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for TokenOutput { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + tokenReceived: data.0, + amountOut: data.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.tokenReceived, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountOut), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 TokenOutput { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&TokenOutput> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(address _boringVault, address _teller); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _boringVault: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _teller: alloy::sol_types::private::Address, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._boringVault, value._teller) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _boringVault: tuple.0, + _teller: 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> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._boringVault, + ), + ::tokenize( + &self._teller, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `boringVault()` and selector `0xf3b97784`. +```solidity +function boringVault() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct boringVaultCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`boringVault()`](boringVaultCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct boringVaultReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: boringVaultCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for boringVaultCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: boringVaultReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for boringVaultReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for boringVaultCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "boringVault()"; + const SELECTOR: [u8; 4] = [243u8, 185u8, 119u8, 132u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: boringVaultReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: boringVaultReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. +```solidity +function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub message: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ); + #[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, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.message) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + message: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageCall { + 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, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; + const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.message, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. +```solidity +function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub args: ::RustType, + } + ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Address, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.args) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + args: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageWithSlippageArgsReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageWithSlippageArgsReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; + const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.args, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `teller()` and selector `0x57edab4e`. +```solidity +function teller() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct tellerCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`teller()`](tellerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct tellerReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tellerCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for tellerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tellerReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for tellerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for tellerCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "teller()"; + const SELECTOR: [u8; 4] = [87u8, 237u8, 171u8, 78u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: tellerReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: tellerReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`HybridBTCStrategy`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum HybridBTCStrategyCalls { + #[allow(missing_docs)] + boringVault(boringVaultCall), + #[allow(missing_docs)] + handleGatewayMessage(handleGatewayMessageCall), + #[allow(missing_docs)] + handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), + #[allow(missing_docs)] + teller(tellerCall), + } + #[automatically_derived] + impl HybridBTCStrategyCalls { + /// 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, 99u8, 76u8, 14u8], + [87u8, 237u8, 171u8, 78u8], + [127u8, 129u8, 79u8, 53u8], + [243u8, 185u8, 119u8, 132u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for HybridBTCStrategyCalls { + const NAME: &'static str = "HybridBTCStrategyCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 4usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::boringVault(_) => { + ::SELECTOR + } + Self::handleGatewayMessage(_) => { + ::SELECTOR + } + Self::handleGatewayMessageWithSlippageArgs(_) => { + ::SELECTOR + } + Self::teller(_) => ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(HybridBTCStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn teller( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(HybridBTCStrategyCalls::teller) + } + teller + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + HybridBTCStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + { + fn boringVault( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(HybridBTCStrategyCalls::boringVault) + } + boringVault + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(HybridBTCStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn teller( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(HybridBTCStrategyCalls::teller) + } + teller + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + HybridBTCStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + { + fn boringVault( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(HybridBTCStrategyCalls::boringVault) + } + boringVault + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::boringVault(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::handleGatewayMessage(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::teller(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::boringVault(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::handleGatewayMessage(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::teller(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + ///Container for all the [`HybridBTCStrategy`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum HybridBTCStrategyEvents { + #[allow(missing_docs)] + TokenOutput(TokenOutput), + } + #[automatically_derived] + impl HybridBTCStrategyEvents { + /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for HybridBTCStrategyEvents { + const NAME: &'static str = "HybridBTCStrategyEvents"; + const COUNT: usize = 1usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::TokenOutput) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 HybridBTCStrategyEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`HybridBTCStrategy`](self) contract instance. + +See the [wrapper's documentation](`HybridBTCStrategyInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> HybridBTCStrategyInstance { + HybridBTCStrategyInstance::::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: alloy_contract::private::Network, + >( + provider: P, + _boringVault: alloy::sol_types::private::Address, + _teller: alloy::sol_types::private::Address, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + HybridBTCStrategyInstance::::deploy(provider, _boringVault, _teller) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + _boringVault: alloy::sol_types::private::Address, + _teller: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + HybridBTCStrategyInstance::< + P, + N, + >::deploy_builder(provider, _boringVault, _teller) + } + /**A [`HybridBTCStrategy`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`HybridBTCStrategy`](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 HybridBTCStrategyInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for HybridBTCStrategyInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("HybridBTCStrategyInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > HybridBTCStrategyInstance { + /**Creates a new wrapper around an on-chain [`HybridBTCStrategy`](self) contract instance. + +See the [wrapper's documentation](`HybridBTCStrategyInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + _boringVault: alloy::sol_types::private::Address, + _teller: alloy::sol_types::private::Address, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(provider, _boringVault, _teller); + 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, + _boringVault: alloy::sol_types::private::Address, + _teller: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + _boringVault, + _teller, + }, + )[..], + ] + .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 HybridBTCStrategyInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> HybridBTCStrategyInstance { + HybridBTCStrategyInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > HybridBTCStrategyInstance { + /// 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( + &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 [`boringVault`] function. + pub fn boringVault( + &self, + ) -> alloy_contract::SolCallBuilder<&P, boringVaultCall, N> { + self.call_builder(&boringVaultCall) + } + ///Creates a new call builder for the [`handleGatewayMessage`] function. + pub fn handleGatewayMessage( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + message: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { + self.call_builder( + &handleGatewayMessageCall { + tokenSent, + amountIn, + recipient, + message, + }, + ) + } + ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. + pub fn handleGatewayMessageWithSlippageArgs( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + args: ::RustType, + ) -> alloy_contract::SolCallBuilder< + &P, + handleGatewayMessageWithSlippageArgsCall, + N, + > { + self.call_builder( + &handleGatewayMessageWithSlippageArgsCall { + tokenSent, + amountIn, + recipient, + args, + }, + ) + } + ///Creates a new call builder for the [`teller`] function. + pub fn teller(&self) -> alloy_contract::SolCallBuilder<&P, tellerCall, N> { + self.call_builder(&tellerCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > HybridBTCStrategyInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`TokenOutput`] event. + pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/fullrelaywithverifytest.rs b/crates/bindings/src/hybrid_btc_strategy_forked_wbtc.rs similarity index 67% rename from crates/bindings/src/fullrelaywithverifytest.rs rename to crates/bindings/src/hybrid_btc_strategy_forked_wbtc.rs index 1c20cfab4..5eab76562 100644 --- a/crates/bindings/src/fullrelaywithverifytest.rs +++ b/crates/bindings/src/hybrid_btc_strategy_forked_wbtc.rs @@ -837,7 +837,8 @@ library StdInvariant { } } -interface FullRelayWithVerifyTest { +interface HybridBTCStrategyForkedWbtc { + event TokenOutput(address tokenReceived, uint256 amountOut); event log(string); event log_address(address); event log_array(uint256[] val); @@ -861,35 +862,29 @@ interface FullRelayWithVerifyTest { event log_uint(uint256); event logs(bytes); - constructor(); - function IS_TEST() external view returns (bool); + function amountIn() external view returns (uint256); function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); function excludeContracts() external view returns (address[] memory excludedContracts_); function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); function excludeSenders() external view returns (address[] memory excludedSenders_); function failed() external view returns (bool); - function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); - function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); - function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); - function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); + function setUp() external; + function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); function targetArtifacts() external view returns (string[] memory targetedArtifacts_); function targetContracts() external view returns (address[] memory targetedContracts_); function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); function targetSenders() external view returns (address[] memory targetedSenders_); + function testDepositToVault() external; + function token() external view returns (address); } ``` ...which was generated by the following JSON ABI: ```json [ - { - "type": "constructor", - "inputs": [], - "stateMutability": "nonpayable" - }, { "type": "function", "name": "IS_TEST", @@ -903,6 +898,19 @@ interface FullRelayWithVerifyTest { ], "stateMutability": "view" }, + { + "type": "function", + "name": "amountIn", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, { "type": "function", "name": "excludeArtifacts", @@ -982,119 +990,38 @@ interface FullRelayWithVerifyTest { }, { "type": "function", - "name": "getBlockHeights", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getDigestLes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes32[]", - "internalType": "bytes32[]" - } - ], - "stateMutability": "view" + "name": "setUp", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" }, { "type": "function", - "name": "getHeaderHexes", + "name": "simulateForkAndTransfer", "inputs": [ { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", + "name": "forkAtBlock", "type": "uint256", "internalType": "uint256" }, { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes[]", - "internalType": "bytes[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaders", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" + "name": "sender", + "type": "address", + "internalType": "address" }, { - "name": "from", - "type": "uint256", - "internalType": "uint256" + "name": "receiver", + "type": "address", + "internalType": "address" }, { - "name": "to", + "name": "amount", "type": "uint256", "internalType": "uint256" } ], - "outputs": [ - { - "name": "headers", - "type": "bytes", - "internalType": "bytes" - } - ], - "stateMutability": "view" + "outputs": [], + "stateMutability": "nonpayable" }, { "type": "function", @@ -1210,6 +1137,45 @@ interface FullRelayWithVerifyTest { ], "stateMutability": "view" }, + { + "type": "function", + "name": "testDepositToVault", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "token", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IERC20" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "TokenOutput", + "inputs": [ + { + "name": "tokenReceived", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "amountOut", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, { "type": "event", "name": "log", @@ -1583,31 +1549,147 @@ interface FullRelayWithVerifyTest { clippy::style, clippy::empty_structs_with_brackets )] -pub mod FullRelayWithVerifyTest { +pub mod HybridBTCStrategyForkedWbtc { use super::*; use alloy::sol_types as alloy_sol_types; /// 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"`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90Ua\x01\0`@R`P`\x80\x81\x81R\x90aL\xFC`\xA09`!\x90a\0=\x90\x82a\x06\x9DV[P`@Q\x80a\x01`\x01`@R\x80a\x01@\x81R` \x01aMla\x01@\x919`\"\x90a\0g\x90\x82a\x06\x9DV[P\x7FH\xE5\xA1\xA0\xE6\x16\xD8\xFD\x92\xB4\xEF\"\x8CBN\x0C\x81g\x99\xA2V\xC6\xA9\x08\x92\x19\\\xCF\xC53\0\xD6`#Ua\x01\x19`$U4\x80\x15a\0\x9DW__\xFD[P`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k42\xB0\xB22\xB99\x9759\xB7\xB7`\xA1\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k\x05\xCC\xEC\xAD\xCC\xAEm.e\xCD\x0C\xAF`\xA3\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x0F\x81R` \x01n\x0B\x99\xD9[\x99\\\xDA\\\xCB\x9A\x19ZY\xDA\x1D`\x8A\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01q.genesis.digest_le`p\x1B\x81RP__Q` aML_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x16c\xD90\xA0\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\x84W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01\xAB\x91\x90\x81\x01\x90a\x07\xCCV[\x90P_\x81\x86`@Q` \x01a\x01\xC1\x92\x91\x90a\x08/V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Rc`\xF9\xBB\x11`\xE0\x1B\x82R\x91P_Q` aML_9_Q\x90_R\x90c`\xF9\xBB\x11\x90a\x02\x01\x90\x84\x90`\x04\x01a\x08\xA1V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x1BW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x02B\x91\x90\x81\x01\x90a\x07\xCCV[` \x90a\x02O\x90\x82a\x06\x9DV[Pa\x02\xE6\x85` \x80Ta\x02a\x90a\x06\x19V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\x8D\x90a\x06\x19V[\x80\x15a\x02\xD8W\x80`\x1F\x10a\x02\xAFWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02\xD8V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02\xBBW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x04\xD4\x91PPV[a\x03|\x85` \x80Ta\x02\xF7\x90a\x06\x19V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03#\x90a\x06\x19V[\x80\x15a\x03nW\x80`\x1F\x10a\x03EWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03nV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03QW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x05Q\x91PPV[a\x04\x12\x85` \x80Ta\x03\x8D\x90a\x06\x19V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xB9\x90a\x06\x19V[\x80\x15a\x04\x04W\x80`\x1F\x10a\x03\xDBWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x04\x04V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xE7W\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x05\xC4\x91PPV[`@Qa\x04\x1E\x90a\x05\xF8V[a\x04*\x93\x92\x91\x90a\x08\xB3V[`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x04CW=__>=_\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16a\x01\0`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x81\x02\x91\x90\x91\x17\x91\x82\x90U`@Qc\xF5\x8D\xB0o`\xE0\x1B\x81R`\x01`\x04\x82\x01\x81\x90R`$\x82\x01R\x91\x04\x90\x91\x16\x96Pc\xF5\x8D\xB0o\x95P`D\x01\x93Pa\x04\xA2\x92PPPV[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xB9W__\xFD[PZ\xF1\x15\x80\x15a\x04\xCBW=__>=_\xFD[PPPPa\t\x12V[`@Qc\x1F\xB2C}`\xE3\x1B\x81R``\x90_Q` aML_9_Q\x90_R\x90c\xFD\x92\x1B\xE8\x90a\x05\t\x90\x86\x90\x86\x90`\x04\x01a\x08\xD7V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05#W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x05J\x91\x90\x81\x01\x90a\x07\xCCV[\x93\x92PPPV[`@QcV\xEE\xF1[`\xE1\x1B\x81R_\x90_Q` aML_9_Q\x90_R\x90c\xAD\xDD\xE2\xB6\x90a\x05\x85\x90\x86\x90\x86\x90`\x04\x01a\x08\xD7V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xA0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05J\x91\x90a\x08\xFBV[`@Qc\x17w\xE5\x9D`\xE0\x1B\x81R_\x90_Q` aML_9_Q\x90_R\x90c\x17w\xE5\x9D\x90a\x05\x85\x90\x86\x90\x86\x90`\x04\x01a\x08\xD7V[a);\x80a#\xC1\x839\x01\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x06-W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x06KWcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\x06\x98W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x06vWP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x06\x95W_\x81U`\x01\x01a\x06\x82V[PP[PPPV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x06\xB6Wa\x06\xB6a\x06\x05V[a\x06\xCA\x81a\x06\xC4\x84Ta\x06\x19V[\x84a\x06QV[` `\x1F\x82\x11`\x01\x81\x14a\x06\xFCW_\x83\x15a\x06\xE5WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x06\x95V[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x07+W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x07\x0BV[P\x84\x82\x10\x15a\x07HW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[_\x80`\x01`\x01`@\x1B\x03\x84\x11\x15a\x07pWa\x07pa\x06\x05V[P`@Q`\x1F\x19`\x1F\x85\x01\x81\x16`?\x01\x16\x81\x01\x81\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17\x15a\x07\x9EWa\x07\x9Ea\x06\x05V[`@R\x83\x81R\x90P\x80\x82\x84\x01\x85\x10\x15a\x07\xB5W__\xFD[\x83\x83` \x83\x01^_` \x85\x83\x01\x01RP\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x07\xDCW__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x07\xF1W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x08\x01W__\xFD[a\x08\x10\x84\x82Q` \x84\x01a\x07WV[\x94\x93PPPPV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x08:\x82\x85a\x08\x18V[\x7F/test/fullRelay/testData/\0\0\0\0\0\0\0\x81Ra\x08j`\x19\x82\x01\x85a\x08\x18V[\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R_a\x05J` \x83\x01\x84a\x08sV[``\x81R_a\x08\xC5``\x83\x01\x86a\x08sV[` \x83\x01\x94\x90\x94RP`@\x01R\x91\x90PV[`@\x81R_a\x08\xE9`@\x83\x01\x85a\x08sV[\x82\x81\x03` \x84\x01Ra\x08j\x81\x85a\x08sV[_` \x82\x84\x03\x12\x15a\t\x0BW__\xFD[PQ\x91\x90PV[a\x1A\xA2\x80a\t\x1F_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xFBW_5`\xE0\x1C\x80c\x85\"l\x81\x11a\0\x93W\x80c\xBAAO\xA6\x11a\0cW\x80c\xBAAO\xA6\x14a\x01\xF1W\x80c\xE2\x0C\x9Fq\x14a\x02\tW\x80c\xFAv&\xD4\x14a\x02\x11W\x80c\xFA\xD0k\x8F\x14a\x02\x1EW__\xFD[\x80c\x85\"l\x81\x14a\x01\xB7W\x80c\x91j\x17\xC6\x14a\x01\xCCW\x80c\xB0FO\xDC\x14a\x01\xE1W\x80c\xB5P\x8A\xA9\x14a\x01\xE9W__\xFD[\x80c>^<#\x11a\0\xCEW\x80c>^<#\x14a\x01rW\x80c?r\x86\xF4\x14a\x01zW\x80cD\xBA\xDB\xB6\x14a\x01\x82W\x80cf\xD9\xA9\xA0\x14a\x01\xA2W__\xFD[\x80c\x08\x13\x85*\x14a\0\xFFW\x80c\x1C\r\xA8\x1F\x14a\x01(W\x80c\x1E\xD7\x83\x1C\x14a\x01HW\x80c*\xDE8\x80\x14a\x01]W[__\xFD[a\x01\x12a\x01\r6`\x04a\x13\x89V[a\x021V[`@Qa\x01\x1F\x91\x90a\x14>V[`@Q\x80\x91\x03\x90\xF3[a\x01;a\x0166`\x04a\x13\x89V[a\x02|V[`@Qa\x01\x1F\x91\x90a\x14\xA1V[a\x01Pa\x02\xEEV[`@Qa\x01\x1F\x91\x90a\x14\xB3V[a\x01ea\x03[V[`@Qa\x01\x1F\x91\x90a\x15eV[a\x01Pa\x04\xA4V[a\x01Pa\x05\x0FV[a\x01\x95a\x01\x906`\x04a\x13\x89V[a\x05zV[`@Qa\x01\x1F\x91\x90a\x15\xE9V[a\x01\xAAa\x05\xBDV[`@Qa\x01\x1F\x91\x90a\x16|V[a\x01\xBFa\x076V[`@Qa\x01\x1F\x91\x90a\x16\xFAV[a\x01\xD4a\x08\x01V[`@Qa\x01\x1F\x91\x90a\x17\x0CV[a\x01\xD4a\t\x04V[a\x01\xBFa\n\x07V[a\x01\xF9a\n\xD2V[`@Q\x90\x15\x15\x81R` \x01a\x01\x1FV[a\x01Pa\x0B\xA2V[`\x1FTa\x01\xF9\x90`\xFF\x16\x81V[a\x01\x95a\x02,6`\x04a\x13\x89V[a\x0C\rV[``a\x02t\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x0CPV[\x94\x93PPPPV[``_a\x02\x8A\x85\x85\x85a\x021V[\x90P_[a\x02\x98\x85\x85a\x17\xBDV[\x81\x10\x15a\x02\xE5W\x82\x82\x82\x81Q\x81\x10a\x02\xB2Wa\x02\xB2a\x17\xD0V[` \x02` \x01\x01Q`@Q` \x01a\x02\xCB\x92\x91\x90a\x18\x14V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x02\x8EV[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03QW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03&W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\x84W\x83\x82\x90_R` _ \x01\x80Ta\x03\xF9\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x04%\x90a\x18(V[\x80\x15a\x04pW\x80`\x1F\x10a\x04GWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x04pV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x04SW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03\xDCV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x03~V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03QW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03&WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03QW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03&WPPPPP\x90P\x90V[``a\x02t\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\r\xB1V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x06\x10\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06<\x90a\x18(V[\x80\x15a\x06\x87W\x80`\x1F\x10a\x06^Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x06\x87V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x06jW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07\x1EW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x06\xCBW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05\xE0V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW\x83\x82\x90_R` _ \x01\x80Ta\x07v\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07\xA2\x90a\x18(V[\x80\x15a\x07\xEDW\x80`\x1F\x10a\x07\xC4Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07\xEDV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\xD0W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x07YV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x08\xECW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x08\x99W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x08$V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\t\xEFW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\t\x9CW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\t'V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW\x83\x82\x90_R` _ \x01\x80Ta\nG\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\ns\x90a\x18(V[\x80\x15a\n\xBEW\x80`\x1F\x10a\n\x95Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\xBEV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\n\xA1W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\n*V[`\x08T_\x90`\xFF\x16\x15a\n\xE9WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0BwW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\x9B\x91\x90a\x18yV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03QW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03&WPPPPP\x90P\x90V[``a\x02t\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x0E\xFFV[``a\x0C\\\x84\x84a\x17\xBDV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0CtWa\x0Cta\x13\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0C\xA7W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x0C\x92W\x90P[P\x90P\x83[\x83\x81\x10\x15a\r\xA8Wa\rz\x86a\x0C\xC1\x83a\x10MV[\x85`@Q` \x01a\x0C\xD4\x93\x92\x91\x90a\x18\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x0C\xF0\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\x1C\x90a\x18(V[\x80\x15a\rgW\x80`\x1F\x10a\r>Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rgV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\rJW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x11~\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\r\x85\x87\x84a\x17\xBDV[\x81Q\x81\x10a\r\x95Wa\r\x95a\x17\xD0V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x0C\xACV[P\x94\x93PPPPV[``a\r\xBD\x84\x84a\x17\xBDV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\xD5Wa\r\xD5a\x13\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\r\xFEW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\r\xA8Wa\x0E\xD1\x86a\x0E\x18\x83a\x10MV[\x85`@Q` \x01a\x0E+\x93\x92\x91\x90a\x18\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x0EG\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0Es\x90a\x18(V[\x80\x15a\x0E\xBEW\x80`\x1F\x10a\x0E\x95Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0E\xBEV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0E\xA1W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x12\x1D\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x0E\xDC\x87\x84a\x17\xBDV[\x81Q\x81\x10a\x0E\xECWa\x0E\xECa\x17\xD0V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x0E\x03V[``a\x0F\x0B\x84\x84a\x17\xBDV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0F#Wa\x0F#a\x13\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0FLW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\r\xA8Wa\x10\x1F\x86a\x0Ff\x83a\x10MV[\x85`@Q` \x01a\x0Fy\x93\x92\x91\x90a\x18\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x0F\x95\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F\xC1\x90a\x18(V[\x80\x15a\x10\x0CW\x80`\x1F\x10a\x0F\xE3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x10\x0CV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\xEFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x12\xB0\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x10*\x87\x84a\x17\xBDV[\x81Q\x81\x10a\x10:Wa\x10:a\x17\xD0V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x0FQV[``\x81_\x03a\x10\x8FWPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x10\xB8W\x80a\x10\xA2\x81a\x19-V[\x91Pa\x10\xB1\x90P`\n\x83a\x19\x91V[\x91Pa\x10\x92V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10\xD2Wa\x10\xD2a\x13\x04V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x10\xFCW` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x02tWa\x11\x11`\x01\x83a\x17\xBDV[\x91Pa\x11\x1E`\n\x86a\x19\xA4V[a\x11)\x90`0a\x19\xB7V[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x11>Wa\x11>a\x17\xD0V[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x11w`\n\x86a\x19\x91V[\x94Pa\x11\0V[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a\x11\xD3\x90\x86\x90\x86\x90`\x04\x01a\x19\xCAV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\xEDW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x12\x14\x91\x90\x81\x01\x90a\x19\xF7V[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x12q\x90\x86\x90\x86\x90`\x04\x01a\x19\xCAV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x12\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\x14\x91\x90a\x18yV[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x12q\x90\x86\x90\x86\x90`\x04\x01a\x19\xCAV[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x13ZWa\x13Za\x13\x04V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x13{Wa\x13{a\x13\x04V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x13\x9BW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x13\xB1W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x13\xC1W__\xFD[\x805a\x13\xD4a\x13\xCF\x82a\x13bV[a\x131V[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x13\xE8W__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\x95W`?\x19\x87\x86\x03\x01\x84Ra\x14\x80\x85\x83Qa\x14\x10V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14dV[P\x92\x96\x95PPPPPPV[` \x81R_a\x12\x14` \x83\x01\x84a\x14\x10V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x15\0W\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\x14\xCCV[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x15YW`\x1F\x19\x85\x84\x03\x01\x88Ra\x15C\x83\x83Qa\x14\x10V[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x15'V[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\x95W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x15\xD3`@\x87\x01\x82a\x15\x0BV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\x8BV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x15\0W\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x16\x02V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x16rW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x162V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\x95W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x16\xC8`@\x88\x01\x82a\x14\x10V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x16\xE3\x81\x83a\x16 V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16\xA2V[` \x81R_a\x12\x14` \x83\x01\x84a\x15\x0BV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\x95W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x17z`@\x87\x01\x82a\x16 V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x172V[\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\x12\x17Wa\x12\x17a\x17\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x02ta\x18\"\x83\x86a\x17\xFDV[\x84a\x17\xFDV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x18\x8C\xAC\xFCl\xA6\xB3\xAF*\xB1o\xAC\x03\xE4D\x1E5\x1A\xDFCS.\xD3\xDF\x83\xE2\n\xF4n\xBEdsolcC\0\x08\x1C\x003`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa);8\x03\x80a);\x839\x81\x01`@\x81\x90Ra\0.\x91a\x03+V[\x82\x82\x82\x82\x82\x82a\0?\x83Q`P\x14\x90V[a\0\x84W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x11`$\x82\x01RpBad genesis block`x\x1B`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\0\x8E\x84a\x01fV[\x90Pb\xFF\xFF\xFF\x82\x16\x15a\x01\tW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FPeriod start hash does not have `D\x82\x01R\x7Fwork. Hint: wrong byte order?\0\0\0`d\x82\x01R`\x84\x01a\0{V[_\x81\x81U`\x01\x82\x90U`\x02\x82\x90U\x81\x81R`\x04` R`@\x90 \x83\x90Ua\x012a\x07\xE0\x84a\x03\xFEV[a\x01<\x90\x84a\x04%V[_\x83\x81R`\x04` R`@\x90 Ua\x01S\x84a\x02&V[`\x05UPa\x05\xBD\x98PPPPPPPPPV[_`\x02\x80\x83`@Qa\x01x\x91\x90a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\x93W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x04NV[`@Q` \x01a\x01\xC8\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x01\xE2\x91a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\xFDW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02 \x91\x90a\x04NV[\x92\x91PPV[_a\x02 a\x023\x83a\x028V[a\x02CV[_a\x02 \x82\x82a\x02SV[_a\x02 a\xFF\xFF`\xD0\x1B\x83a\x02\xF7V[_\x80a\x02ja\x02c\x84`Ha\x04eV[\x85\x90a\x03\tV[`\xE8\x1C\x90P_\x84a\x02|\x85`Ka\x04eV[\x81Q\x81\x10a\x02\x8CWa\x02\x8Ca\x04xV[\x01` \x01Q`\xF8\x1C\x90P_a\x02\xBE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x02\xD1`\x03\x84a\x04\x8CV[`\xFF\x16\x90Pa\x02\xE2\x81a\x01\0a\x05\x88V[a\x02\xEC\x90\x83a\x05\x93V[\x97\x96PPPPPPPV[_a\x03\x02\x82\x84a\x05\xAAV[\x93\x92PPPV[_a\x03\x02\x83\x83\x01` \x01Q\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x03=W__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03RW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03bW__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03{Wa\x03{a\x03\x17V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x03\xA9Wa\x03\xA9a\x03\x17V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x03\xC0W__\xFD[\x81` \x84\x01` \x83\x01^_` \x92\x82\x01\x83\x01R\x90\x86\x01Q`@\x90\x96\x01Q\x90\x97\x95\x96P\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x04\x0CWa\x04\x0Ca\x03\xEAV[P\x06\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x04^W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02 Wa\x02 a\x04\x11V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[`\x01\x81[`\x01\x84\x11\x15a\x04\xE0W\x80\x85\x04\x81\x11\x15a\x04\xC4Wa\x04\xC4a\x04\x11V[`\x01\x84\x16\x15a\x04\xD2W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x04\xA9V[\x93P\x93\x91PPV[_\x82a\x04\xF6WP`\x01a\x02 V[\x81a\x05\x02WP_a\x02 V[\x81`\x01\x81\x14a\x05\x18W`\x02\x81\x14a\x05\"Wa\x05>V[`\x01\x91PPa\x02 V[`\xFF\x84\x11\x15a\x053Wa\x053a\x04\x11V[PP`\x01\x82\x1Ba\x02 V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x05aWP\x81\x81\na\x02 V[a\x05m_\x19\x84\x84a\x04\xA5V[\x80_\x19\x04\x82\x11\x15a\x05\x80Wa\x05\x80a\x04\x11V[\x02\x93\x92PPPV[_a\x03\x02\x83\x83a\x04\xE8V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x02 Wa\x02 a\x04\x11V[_\x82a\x05\xB8Wa\x05\xB8a\x03\xEAV[P\x04\x90V[a#q\x80a\x05\xCA_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\xADW\x80c\xB9\x85b\x1A\x11a\0}W\x80c\xE3\xD8\xD8\xD8\x11a\0cW\x80c\xE3\xD8\xD8\xD8\x14a\x02\"W\x80c\xE4q\xE7,\x14a\x02)W\x80c\xF5\x8D\xB0o\x14a\x02=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x13\x91\x90a!WV[`@Q` \x01a\x0C%\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\x90\x82\x90Ra\x0C]\x91a!AV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0CxW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x07\x91\x90a!WV[_\x83\x85\x14\x80\x15a\x0C\xAAWP\x82\x85\x14[\x15a\x0C\xB7WP`\x01a\x04\xF1V[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x0C\xFFW\x89\x83\x14a\x0C\xDEW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x0C\xF7W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x0C\xBDV[P\x82\x84\x03a\r\x13W_\x94PPPPPa\x04\xF1V[\x80\x82\x14a\r&W_\x94PPPPPa\x04\xF1V[P`\x01\x98\x97PPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\rYW_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\r9V[P\x80a\x05\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x80\x82\x81[a\r\xB8`\x04`\x01a!\x9BV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0E\x0CW_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\r\xF1W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0E\x04V[a\r\xFB\x81\x84a!\xB7V[\x95\x94PPPPPV[`\x01\x01a\r\xACV[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_`P\x82Qa\x0B~\x91\x90a!.V[__a\x0Eo\x85a\x0B\xC3V[\x90P_a\x0E{\x82a\r\xA7V[\x90P_a\x0E\x87\x86a\x19\xE6V[\x90P\x84\x80a\x0E\x9CWP\x80a\x0E\x9A\x88a\x19\xE6V[\x14[a\x0F\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x03.V[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x12\x0EWa\x0F(`P\x82a!\xCAV[a\x0F3\x90`\x01a!\xB7V[a\x0F=\x90\x87a!\xB7V[\x93Pa\x0FK\x8A\x82`Pa\x19\xF1V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x11!W\x84a\x10\xA1\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x10\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x11\n`\x04\x85a!.V[_\x03a\x11!W_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x11,\x8B\x83a\x1A\x16V[\x14a\x11yW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[\x86a\x11\x84\x8B\x83a\x1A\xAFV[\x14a\x11\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x03.V[\x82\x96P`P\x81a\x12\x07\x91\x90a!\xB7V[\x90Pa\x0F\x15V[P\x81a\x12\x19\x8Ba\x0B\xC3V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x12\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x12\xD4\x84a\x0B\xC3V[\x90P_a\x12\xE0\x86a\x0B\xC3V[\x90P`\x01T\x81\x14a\x133W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x03.V[_\x82\x81R`\x03` R`@\x90 Ta\x13\x8DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x13\x9B\x87`\x01T\x84\x87a\x0C\x9BV[a\x14\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x03.V[\x81a\x14\x19\x88\x88\x88a\x17\x80V[\x14a\x14\x8CW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[`\x01\x82\x90U`\x02\x87\x90U_a\x14\xA0\x86a\x1A\xC7V[\x90P`\x05T\x81\x14a\x14\xB1W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x15\x01a\x14\xFC\x86a\x0B\xC3V[a\r\xA7V[\x90P_a\x15\x10a\x14\xFC\x86a\x0B\xC3V[\x90Pa\x15\x1Ea\x07\xE0\x82a!.V[a\x07\xDF\x14a\x15\x94W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x03.V[a\x15\xA0\x82a\x07\xDFa!\xB7V[\x81\x14a\x16\x14W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x03.V[a\x16\x1D\x85a\x1A\xC7V[a\x16&\x87a\x1A\xC7V[\x14a\x16\x99W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x03.V[_a\x16\xA3\x85a\x19\xE6V[\x90P_a\x16\xD5a\x16\xB2\x89a\x19\xE6V[a\x16\xBB\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x16\xCA\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x1B\x0CV[\x90P\x81\x81\x83\x16\x14a\x17(W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_a\x172\x89a\x1A\xC7V[\x90P\x80`\x06T\x14\x15\x80\x15a\x17\\WPa\x07\xE0a\x17O`\x01Ta\r\xA7V[a\x17Y\x91\x90a!\xDDV[\x84\x11[\x15a\x17gW`\x06\x81\x90U[a\x17s\x88\x88`\x01a\x0EdV[\x99\x98PPPPPPPPPV[__a\x17\x8B\x85a\r\xA7V[\x90P_a\x17\x9Aa\x14\xFC\x86a\x0B\xC3V[\x90P_a\x17\xA9a\x14\xFC\x86a\x0B\xC3V[\x90P\x82\x82\x10\x15\x80\x15a\x17\xBBWP\x82\x81\x10\x15[a\x18-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x18:a\x07\xE0\x85a!.V[a\x18F\x85a\x07\xE0a!\xB7V[a\x18P\x91\x90a!\xDDV[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x18bWP\x80[\x15a\x18}Wa\x18p\x89a\x0B\xC3V[\x96PPPPPPPa\n\xA3V[\x81\x80\x15a\x18\x88WP\x80\x15[\x15a\x18\x96Wa\x18p\x88a\x0B\xC3V[\x81\x80\x15a\x18\xA0WP\x80[\x15a\x18\xC4W\x83\x85\x10\x15a\x18\xBBWa\x18\xB6\x88a\x0B\xC3V[a\x18pV[a\x18p\x89a\x0B\xC3V[a\x18\xCD\x88a\x1A\xC7V[a\x18\xD9a\x07\xE0\x86a!.V[a\x18\xE3\x91\x90a!\xF0V[a\x18\xEC\x8Aa\x1A\xC7V[a\x18\xF8a\x07\xE0\x88a!.V[a\x19\x02\x91\x90a!\xF0V[\x10\x15a\x18\xBBWa\x18p\x88a\x0B\xC3V[`\x07T_\x90`\xFF\x16\x15a\x19/WP`\x07Ta\x01\0\x90\x04`\xFF\x16a\n\xA3V[a\x19:\x84\x84\x84a\x1B\x94V[\x90Pa\n\xA3V[_` \x84Qa\x19P\x91\x90a!.V[\x15a\x19\\WP_a\x04\xF1V[\x83Q_\x03a\x19kWP_a\x04\xF1V[\x81\x85_[\x86Q\x81\x10\x15a\x19\xD9Wa\x19\x83`\x02\x84a!.V[`\x01\x03a\x19\xA7Wa\x19\xA0a\x19\x9A\x88\x83\x01` \x01Q\x90V[\x83a\x1B\xD5V[\x91Pa\x19\xC0V[a\x19\xBD\x82a\x19\xB8\x89\x84\x01` \x01Q\x90V[a\x1B\xD5V[\x91P[`\x01\x92\x90\x92\x1C\x91a\x19\xD2` \x82a!\xB7V[\x90Pa\x19oV[P\x90\x93\x14\x95\x94PPPPPV[_a\x05\x07\x82_a\x1A\x16V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x1A-a\x1A&\x84`Ha!\xB7V[\x85\x90a\x1B\xE0V[`\xE8\x1C\x90P_\x84a\x1A?\x85`Ka!\xB7V[\x81Q\x81\x10a\x1AOWa\x1AOa\"\x07V[\x01` \x01Q`\xF8\x1C\x90P_a\x1A\x81\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1A\x94`\x03\x84a\"4V[`\xFF\x16\x90Pa\x1A\xA5\x81a\x01\0a#0V[a\x08-\x90\x83a!\xF0V[_a\x05\x04a\x1A\xBE\x83`\x04a!\xB7V[\x84\x01` \x01Q\x90V[_a\x05\x07a\x1A\xD4\x83a\x19\xE6V[a\x1B\xEEV[_a\x05\x07a\x1A\xE6\x83a\x1C\x15V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1B\x18\x83\x85a\x1C!V[\x90Pa\x1B(b\x12u\0`\x04a\x1C|V[\x81\x10\x15a\x1B@Wa\x1B=b\x12u\0`\x04a\x1C|V[\x90P[a\x1BNb\x12u\0`\x04a\x1C\x87V[\x81\x11\x15a\x1BfWa\x1Bcb\x12u\0`\x04a\x1C\x87V[\x90P[_a\x1B~\x82a\x1Bx\x88b\x01\0\0a\x1C|V[\x90a\x1C\x87V[\x90Pa\n\x8Ab\x01\0\0a\x1Bx\x83b\x12u\0a\x1C|V[_\x82\x81[\x83\x81\x10\x15a\x1B\xCAW\x85\x82\x03a\x1B\xB2W`\x01\x92PPPa\n\xA3V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x1B\x98V[P_\x95\x94PPPPPV[_a\x05\x04\x83\x83a\x1C\xFAV[_a\x05\x04\x83\x83\x01` \x01Q\x90V[_a\x05\x07{\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\x83a\x1C|V[_a\x05\x07\x82`Da\x1B\xE0V[_\x82\x82\x11\x15a\x1CrW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x05\x04\x82\x84a!\xDDV[_a\x05\x04\x82\x84a!\xCAV[_\x82_\x03a\x1C\x96WP_a\x05\x07V[a\x1C\xA0\x82\x84a!\xF0V[\x90P\x81a\x1C\xAD\x84\x83a!\xCAV[\x14a\x05\x07W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x03.V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1D1W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DHW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1D_W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1DvW__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1D\x91W__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xA7W__\xFD[a\x1D\xB3\x8A\x82\x8B\x01a\x1D!V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xD2W__\xFD[a\x1D\xDE\x8A\x82\x8B\x01a\x1D!V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1D\xFE`\x80\x89\x01a\x1DfV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[____`\x80\x85\x87\x03\x12\x15a\x1E\x1FW__\xFD[PP\x825\x94` \x84\x015\x94P`@\x84\x015\x93``\x015\x92P\x90PV[__`@\x83\x85\x03\x12\x15a\x1ELW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1EkW__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1E\x85W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x9BW__\xFD[a\x1E\xA7\x87\x82\x88\x01a\x1D!V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\xC6W__\xFD[a\x1E\xD2\x87\x82\x88\x01a\x1D!V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1E\xF3W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x10W__\xFD[a\x1F\x1C\x89\x82\x8A\x01a\x1D!V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F;W__\xFD[a\x1FG\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1FtW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x8AW__\xFD[a\x1F\x96\x89\x82\x8A\x01a\x1D!V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xB5W__\xFD[a\x1F\xC1\x89\x82\x8A\x01a\x1D!V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xE0W__\xFD[a\x1F\xEC\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_____``\x86\x88\x03\x12\x15a \x12W__\xFD[\x855\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a /W__\xFD[a ;\x88\x82\x89\x01a\x1D!V[\x90\x95P\x93PP`@\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a ZW__\xFD[a f\x88\x82\x89\x01a\x1D!V[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[___``\x84\x86\x03\x12\x15a \x89W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a \xB1W__\xFD[\x825\x91Pa \xC1` \x84\x01a\x1DfV[\x90P\x92P\x92\x90PV[\x805\x80\x15\x15\x81\x14a\x1DvW__\xFD[__`@\x83\x85\x03\x12\x15a \xEAW__\xFD[a \xF3\x83a \xCAV[\x91Pa \xC1` \x84\x01a \xCAV[\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!\xA9m\xA5\xCFi_\"\xBF}\x94\xBE\x87\xD4\x9D\xB1\xADz\xC3q\xACC\xC4\xDAAa\xC8\xC2\x164\x9C[\xA1\x19(\x17\r8x+\0\0\0\0\0\0\0\0\0\0\0\0q\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\xE3Z\rm\xE9Kef\x94X\x99d\xA2R\x95~Fs\xA9\xFB\x1D/\x8BJ\x92\xE3\xF0\xA7\xBBeO\xDD\xB9NZ\x1Em\x7F\x7FI\x9F\xD1\xBE]\xD3\ns\xBFU\x84\xBF\x13}\xA5\xFD\xD7|\xC2\x1A\xEB\x95\xB9\xE3W\x88\x89K\xE0\x19(K\xD4\xFB\xEDm\xD6\x11\x8A\xC2\xCBm&\xBCK\xE4\xE4#\xF5Z:H\xF2\x87M\x8D\x02\xA6]\x9C\x87\xD0}\xE2\x1DM\xFE{\n\x9FJ#\xCC\x9AX7>\x9Ei1\xFE\xFD\xB5\xAF\xAD\xE5\xDFT\xC9\x11\x04\x04\x8D\xF1\xEE\x99\x92@ay\x84\xE1\x8Bo\x93\x1E#sg=\x01\x95\xB8\xC6\x98}\x7F\xF7e\r\\\xE5;\xCE\xC4n\x13\xABO-\xA1\x14j\x7F\xC6!\xEEg/b\xBC\"t$\x869-u\xE5^g\xB0\x99`\xC38j\x0BI\xE7_\x17#\xD6\xAB(\xAC\x9A (\xA0\xC7(f\xE2\x11\x1Dy\xD4\x81{\x88\xE1|\x82\x197\x84wh\xD9(7\xBA\xE3\x83+\xB8\xE5\xA4\xABD4\xB9~\0\xA6\xC1\x01\x82\xF2\x11\xF5\x92@\x90h\xD6\xF5e$\0\xD9\xA3\xD1\xCC\x15\n\x7F\xB6\x92\xE8t\xCCB\xD7k\xDA\xFC\x84//\xE0\xF85\xA7\xC2M-`\xC1\t\xB1\x87\xD6Eq\xEF\xBA\xA8\x04{\xE8X!\xF8\xE6~\x0E\x85\xF2\xF5\x89K\xC6=\0\xC2\xED\x9Dd", + b"`\x80`@R`\x0C\x80T`\xFF\x19\x90\x81\x16`\x01\x90\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90Uc\x05\xF5\xE1\0` U`!\x80T`\x01`\x01`\xA0\x1B\x03\x19\x90\x81\x16s\x19\xAB\x8C\x98\x96r\x8D:*\xE8gw\x11\xBC\x85,pf\x16\xD3\x17\x90\x91U`\"\x80T\x90\x91\x16s\x99\x98\xE0P0\xAE\xE3\xAF\x9A\xD3\xDF5\xA3O\\Q\xE1b\x87y\x17\x90U4\x80\x15`|W__\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16t\x03\xC7\x05K\xCB9\xF7\xB2\xE5\xB2\xC7\xAC\xB3u\x83\xE3-p\xCF\xA3\0\x17\x90Ua&\xF8\x80a\0\xB2_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80c\x8C\x198a\x11a\0\xADW\x80c\xBAAO\xA6\x11a\0}W\x80c\xF9\xCE\x0EZ\x11a\0cW\x80c\xF9\xCE\x0EZ\x14a\x01\xF4W\x80c\xFAv&\xD4\x14a\x02\x07W\x80c\xFC\x0CTj\x14a\x02\x14W__\xFD[\x80c\xBAAO\xA6\x14a\x01\xD4W\x80c\xE2\x0C\x9Fq\x14a\x01\xECW__\xFD[\x80c\x8C\x198a\x14a\x01\xA7W\x80c\x91j\x17\xC6\x14a\x01\xAFW\x80c\xB0FO\xDC\x14a\x01\xC4W\x80c\xB5P\x8A\xA9\x14a\x01\xCCW__\xFD[\x80c?r\x86\xF4\x11a\0\xE8W\x80c?r\x86\xF4\x14a\x01^W\x80cf\xD9\xA9\xA0\x14a\x01fW\x80ck\xEDU\xA6\x14a\x01{W\x80c\x85\"l\x81\x14a\x01\x92W__\xFD[\x80c\n\x92T\xE4\x14a\x01\x19W\x80c\x1E\xD7\x83\x1C\x14a\x01#W\x80c*\xDE8\x80\x14a\x01AW\x80c>^<#\x14a\x01VW[__\xFD[a\x01!a\x02DV[\0[a\x01+a\x03\nV[`@Qa\x018\x91\x90a\x13\xBEV[`@Q\x80\x91\x03\x90\xF3[a\x01Ia\x03jV[`@Qa\x018\x91\x90a\x147V[a\x01+a\x04\xA6V[a\x01+a\x05\x04V[a\x01na\x05bV[`@Qa\x018\x91\x90a\x15zV[a\x01\x84` T\x81V[`@Q\x90\x81R` \x01a\x018V[a\x01\x9Aa\x06\xDBV[`@Qa\x018\x91\x90a\x15\xF8V[a\x01!a\x07\xA6V[a\x01\xB7a\r\rV[`@Qa\x018\x91\x90a\x16OV[a\x01\xB7a\x0E\x03V[a\x01\x9Aa\x0E\xF9V[a\x01\xDCa\x0F\xC4V[`@Q\x90\x15\x15\x81R` \x01a\x018V[a\x01+a\x10\x94V[a\x01!a\x02\x026`\x04a\x16\xE1V[a\x10\xF2V[`\x1FTa\x01\xDC\x90`\xFF\x16\x81V[`\x1FTa\x02,\x90a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x018V[a\x02}b\xD5\x9F\x80sJ\x1D\xF9qaG\xB7\x85\xF3\xF8 \x19\xF3o$\x8A\xC1]\xC3\x08s\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E` Ta\x10\xF2V[`\"T`!T`@Q`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x92\x90\x91\x16\x90a\x02\x9F\x90a\x13\xB1V[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x02\xCFW=__>=_\xFD[P`#\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`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03`W` \x02\x82\x01\x91\x90_R` _ \x90[\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03BW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\x86W\x83\x82\x90_R` _ \x01\x80Ta\x03\xFB\x90a\x17\"V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x04'\x90a\x17\"V[\x80\x15a\x04rW\x80`\x1F\x10a\x04IWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x04rV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x04UW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03\xDEV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x03\x8DV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03`W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03BWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03`W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03BWPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x05\xB5\x90a\x17\"V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05\xE1\x90a\x17\"V[\x80\x15a\x06,W\x80`\x1F\x10a\x06\x03Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x06,V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x06\x0FW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06\xC3W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x06pW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05\x85V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW\x83\x82\x90_R` _ \x01\x80Ta\x07\x1B\x90a\x17\"V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07G\x90a\x17\"V[\x80\x15a\x07\x92W\x80`\x1F\x10a\x07iWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07\x92V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07uW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x06\xFEV[`\x1FT`@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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R_\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x1EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08B\x91\x90a\x17sV[`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\xBBW__\xFD[PZ\xF1\x15\x80\x15a\x08\xCDW=__>=_\xFD[PP`\x1FT`#T` T`@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\x81R`\x01`\x01`\xA0\x1B\x03\x92\x83\x16`\x04\x82\x01R`$\x81\x01\x91\x90\x91Ra\x01\0\x90\x92\x04\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\tEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\ti\x91\x90a\x17\x8AV[P`#T`@Q\x7F\x86\xB9b\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\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x86\xB9b\r\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t\xD9W__\xFD[PZ\xF1\x15\x80\x15a\t\xEBW=__>=_\xFD[PP`\"T` \x80T`@\x80Q`\x01`\x01`\xA0\x1B\x03\x90\x94\x16\x84R\x91\x83\x01R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x93P\x01\x90P`@Q\x80\x91\x03\x90\xA1`#T`\x1FT` \x80T`@\x80Q\x92\x83\x01\x81R_\x83RQ\x7F\x7F\x81O5\0\0\0\0\0\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\x03a\x01\0\x90\x94\x04\x84\x16`\x04\x82\x01R`$\x81\x01\x91\x90\x91R`\x01`D\x82\x01R\x90Q`d\x82\x01R\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\n\xBFW__\xFD[PZ\xF1\x15\x80\x15a\n\xD1W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0B!W__\xFD[PZ\xF1\x15\x80\x15a\x0B3W=__>=_\xFD[PP`\"T`@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\x81R`\x01`\x04\x82\x01Ra\x0B\xC7\x93P`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0B\x9BW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\xBF\x91\x90a\x17sV[` Ta\x13.V[`\"T`#T`@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\x81R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x04\x82\x01Ra\x0CZ\x92\x91\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0C0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0CT\x91\x90a\x17sV[_a\x13.V[`\x1FT`@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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01Ra\r\n\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0C\xD4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\xF8\x91\x90a\x17sV[` Ta\r\x05\x90\x84a\x17\xB0V[a\x13.V[PV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\xEBW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\x98W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\r0V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0E\xE1W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0E\x8EW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0E&V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW\x83\x82\x90_R` _ \x01\x80Ta\x0F9\x90a\x17\"V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0Fe\x90a\x17\"V[\x80\x15a\x0F\xB0W\x80`\x1F\x10a\x0F\x87Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F\xB0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\x93W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0F\x1CV[`\x08T_\x90`\xFF\x16\x15a\x0F\xDBWP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10iW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\x8D\x91\x90a\x17sV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03`W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03BWPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\x8DW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x11\xB4\x91\x90\x81\x01\x90a\x18\x1BV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x11\xD2\x92\x91\x90a\x18\xCFV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11\xEEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\x12\x91\x90a\x17sV[P`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12~W__\xFD[PZ\xF1\x15\x80\x15a\x12\x90W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x13\x03W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13'\x91\x90a\x17\x8AV[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x13\x97W__\xFD[PZ\xFA\x15\x80\x15a\x13\xA9W=__>=_\xFD[PPPPPPV[a\r\xD2\x80a\x18\xF1\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x13\xFEW\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x13\xD7V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x12W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`\x01`\x01`\xA0\x1B\x03\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x14\xF8W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x14\xE2\x84\x86Qa\x14\tV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x14\xA8V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x14]V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x15pW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x150V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x12W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x15\xC6`@\x88\x01\x82a\x14\tV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x15\xE1\x81\x83a\x15\x1EV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\xA0V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x12W`?\x19\x87\x86\x03\x01\x84Ra\x16:\x85\x83Qa\x14\tV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16\x1EV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x12W`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x16\xB0`@\x87\x01\x82a\x15\x1EV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16uV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x16\xDCW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x16\xF4W__\xFD[\x845\x93Pa\x17\x04` \x86\x01a\x16\xC6V[\x92Pa\x17\x12`@\x86\x01a\x16\xC6V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x176W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x17mW\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17\x83W__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17\x9AW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x17\xA9W__\xFD[\x93\x92PPPV[\x81\x81\x03\x81\x81\x11\x15a\x17\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`\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x18+W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18AW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x18QW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18kWa\x18ka\x17\xEEV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x18\x9BWa\x18\x9Ba\x17\xEEV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x18\xB2W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x18\xE1`@\x83\x01\x85a\x14\tV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\xD28\x03\x80a\r\xD2\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\xF5a\0\xDD_9_\x81\x81`h\x01Ra\x02\x87\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xC1\x01R\x81\x81a\x03\x0F\x01R\x81\x81a\x03}\x01Ra\x04\xB8\x01Ra\x0C\xF5_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cPcL\x0E\x14a\0NW\x80cW\xED\xABN\x14a\0cW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xF3\xB9w\x84\x14a\0\xC6W[__\xFD[a\0aa\0\\6`\x04a\n{V[a\0\xEDV[\0[a\0\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\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\0aa\0\xC16`\x04a\x0B=V[a\x01\x17V[a\0\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\x81V[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\xC1V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x16V[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\xDAV[`@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\x83\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B\xE5V[\x82Q`@Q\x7F\x0E\xFEj\x8B\0\0\0\0\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`$\x82\x01\x88\x90R`D\x82\x01\x92\x90\x92R\x91\x92P_\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\x90\x91\x16\x90c\x0E\xFEj\x8B\x90`d\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02\xCFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xF3\x91\x90a\x0B\xE5V[\x90Pa\x036s\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\x83a\x06\xD5V[`@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_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\xC4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xE8\x91\x90a\x0B\xE5V[\x90P\x82\x81\x11a\x04>W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x04I\x84\x83a\x0C)V[\x85Q\x90\x91P\x81\x10\x15a\x04\x9DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x045V[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\xD4\x90\x85\x90\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\x90`\x84\x01[`@\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\x070V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06NW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06r\x91\x90a\x0B\xE5V[a\x06|\x91\x90a\x0CBV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\xD4\x90\x85\x90\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\x90`d\x01a\x05pV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07+\x90\x84\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\x90`d\x01a\x05pV[PPPV[_a\x07\x91\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\x08!\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07+W\x80\x80` \x01\x90Q\x81\x01\x90a\x07\xAF\x91\x90a\x0CUV[a\x07+W`@QbF\x1B\xCD`\xE5\x1B\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\x045V[``a\x08/\x84\x84_\x85a\x089V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\xB1W`@QbF\x1B\xCD`\xE5\x1B\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\x045V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\x15W`@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\x045V[__\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\t=\x91\x90a\x0CtV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\twW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t|V[``\x91P[P\x91P\x91Pa\t\x8C\x82\x82\x86a\t\x97V[\x97\x96PPPPPPPV[``\x83\x15a\t\xA6WP\x81a\x082V[\x82Q\x15a\t\xB6W\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x045\x91\x90a\x0C\x8AV[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\t\xF1W__\xFD[PV[\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\nDWa\nDa\t\xF4V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\nsWa\nsa\t\xF4V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\n\x8EW__\xFD[\x845a\n\x99\x81a\t\xD0V[\x93P` \x85\x015\x92P`@\x85\x015a\n\xB0\x81a\t\xD0V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xCBW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\xDBW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xF5Wa\n\xF5a\t\xF4V[a\x0B\x08` `\x1F\x19`\x1F\x84\x01\x16\x01a\nJV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0B\x1CW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0BQW__\xFD[\x855a\x0B\\\x81a\t\xD0V[\x94P` \x86\x015\x93P`@\x86\x015a\x0Bs\x81a\t\xD0V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0B\xA4W__\xFD[Pa\x0B\xADa\n!V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\xD2W__\xFD[Pa\x0B\xDBa\n!V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xF5W__\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[\x81\x81\x03\x81\x81\x11\x15a\x0C^<#\x11a\0\xCEW\x80c>^<#\x14a\x01rW\x80c?r\x86\xF4\x14a\x01zW\x80cD\xBA\xDB\xB6\x14a\x01\x82W\x80cf\xD9\xA9\xA0\x14a\x01\xA2W__\xFD[\x80c\x08\x13\x85*\x14a\0\xFFW\x80c\x1C\r\xA8\x1F\x14a\x01(W\x80c\x1E\xD7\x83\x1C\x14a\x01HW\x80c*\xDE8\x80\x14a\x01]W[__\xFD[a\x01\x12a\x01\r6`\x04a\x13\x89V[a\x021V[`@Qa\x01\x1F\x91\x90a\x14>V[`@Q\x80\x91\x03\x90\xF3[a\x01;a\x0166`\x04a\x13\x89V[a\x02|V[`@Qa\x01\x1F\x91\x90a\x14\xA1V[a\x01Pa\x02\xEEV[`@Qa\x01\x1F\x91\x90a\x14\xB3V[a\x01ea\x03[V[`@Qa\x01\x1F\x91\x90a\x15eV[a\x01Pa\x04\xA4V[a\x01Pa\x05\x0FV[a\x01\x95a\x01\x906`\x04a\x13\x89V[a\x05zV[`@Qa\x01\x1F\x91\x90a\x15\xE9V[a\x01\xAAa\x05\xBDV[`@Qa\x01\x1F\x91\x90a\x16|V[a\x01\xBFa\x076V[`@Qa\x01\x1F\x91\x90a\x16\xFAV[a\x01\xD4a\x08\x01V[`@Qa\x01\x1F\x91\x90a\x17\x0CV[a\x01\xD4a\t\x04V[a\x01\xBFa\n\x07V[a\x01\xF9a\n\xD2V[`@Q\x90\x15\x15\x81R` \x01a\x01\x1FV[a\x01Pa\x0B\xA2V[`\x1FTa\x01\xF9\x90`\xFF\x16\x81V[a\x01\x95a\x02,6`\x04a\x13\x89V[a\x0C\rV[``a\x02t\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x0CPV[\x94\x93PPPPV[``_a\x02\x8A\x85\x85\x85a\x021V[\x90P_[a\x02\x98\x85\x85a\x17\xBDV[\x81\x10\x15a\x02\xE5W\x82\x82\x82\x81Q\x81\x10a\x02\xB2Wa\x02\xB2a\x17\xD0V[` \x02` \x01\x01Q`@Q` \x01a\x02\xCB\x92\x91\x90a\x18\x14V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x02\x8EV[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03QW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03&W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\x84W\x83\x82\x90_R` _ \x01\x80Ta\x03\xF9\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x04%\x90a\x18(V[\x80\x15a\x04pW\x80`\x1F\x10a\x04GWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x04pV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x04SW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03\xDCV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x03~V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03QW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03&WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03QW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03&WPPPPP\x90P\x90V[``a\x02t\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\r\xB1V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x06\x10\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06<\x90a\x18(V[\x80\x15a\x06\x87W\x80`\x1F\x10a\x06^Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x06\x87V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x06jW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07\x1EW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x06\xCBW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05\xE0V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW\x83\x82\x90_R` _ \x01\x80Ta\x07v\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07\xA2\x90a\x18(V[\x80\x15a\x07\xEDW\x80`\x1F\x10a\x07\xC4Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07\xEDV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\xD0W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x07YV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x08\xECW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x08\x99W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x08$V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\t\xEFW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\t\x9CW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\t'V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW\x83\x82\x90_R` _ \x01\x80Ta\nG\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\ns\x90a\x18(V[\x80\x15a\n\xBEW\x80`\x1F\x10a\n\x95Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\xBEV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\n\xA1W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\n*V[`\x08T_\x90`\xFF\x16\x15a\n\xE9WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0BwW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\x9B\x91\x90a\x18yV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03QW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03&WPPPPP\x90P\x90V[``a\x02t\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x0E\xFFV[``a\x0C\\\x84\x84a\x17\xBDV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0CtWa\x0Cta\x13\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0C\xA7W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x0C\x92W\x90P[P\x90P\x83[\x83\x81\x10\x15a\r\xA8Wa\rz\x86a\x0C\xC1\x83a\x10MV[\x85`@Q` \x01a\x0C\xD4\x93\x92\x91\x90a\x18\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x0C\xF0\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\x1C\x90a\x18(V[\x80\x15a\rgW\x80`\x1F\x10a\r>Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rgV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\rJW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x11~\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\r\x85\x87\x84a\x17\xBDV[\x81Q\x81\x10a\r\x95Wa\r\x95a\x17\xD0V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x0C\xACV[P\x94\x93PPPPV[``a\r\xBD\x84\x84a\x17\xBDV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\xD5Wa\r\xD5a\x13\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\r\xFEW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\r\xA8Wa\x0E\xD1\x86a\x0E\x18\x83a\x10MV[\x85`@Q` \x01a\x0E+\x93\x92\x91\x90a\x18\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x0EG\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0Es\x90a\x18(V[\x80\x15a\x0E\xBEW\x80`\x1F\x10a\x0E\x95Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0E\xBEV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0E\xA1W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x12\x1D\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x0E\xDC\x87\x84a\x17\xBDV[\x81Q\x81\x10a\x0E\xECWa\x0E\xECa\x17\xD0V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x0E\x03V[``a\x0F\x0B\x84\x84a\x17\xBDV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0F#Wa\x0F#a\x13\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0FLW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\r\xA8Wa\x10\x1F\x86a\x0Ff\x83a\x10MV[\x85`@Q` \x01a\x0Fy\x93\x92\x91\x90a\x18\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x0F\x95\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F\xC1\x90a\x18(V[\x80\x15a\x10\x0CW\x80`\x1F\x10a\x0F\xE3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x10\x0CV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\xEFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x12\xB0\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x10*\x87\x84a\x17\xBDV[\x81Q\x81\x10a\x10:Wa\x10:a\x17\xD0V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x0FQV[``\x81_\x03a\x10\x8FWPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x10\xB8W\x80a\x10\xA2\x81a\x19-V[\x91Pa\x10\xB1\x90P`\n\x83a\x19\x91V[\x91Pa\x10\x92V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10\xD2Wa\x10\xD2a\x13\x04V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x10\xFCW` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x02tWa\x11\x11`\x01\x83a\x17\xBDV[\x91Pa\x11\x1E`\n\x86a\x19\xA4V[a\x11)\x90`0a\x19\xB7V[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x11>Wa\x11>a\x17\xD0V[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x11w`\n\x86a\x19\x91V[\x94Pa\x11\0V[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a\x11\xD3\x90\x86\x90\x86\x90`\x04\x01a\x19\xCAV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\xEDW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x12\x14\x91\x90\x81\x01\x90a\x19\xF7V[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x12q\x90\x86\x90\x86\x90`\x04\x01a\x19\xCAV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x12\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\x14\x91\x90a\x18yV[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x12q\x90\x86\x90\x86\x90`\x04\x01a\x19\xCAV[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x13ZWa\x13Za\x13\x04V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x13{Wa\x13{a\x13\x04V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x13\x9BW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x13\xB1W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x13\xC1W__\xFD[\x805a\x13\xD4a\x13\xCF\x82a\x13bV[a\x131V[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x13\xE8W__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\x95W`?\x19\x87\x86\x03\x01\x84Ra\x14\x80\x85\x83Qa\x14\x10V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14dV[P\x92\x96\x95PPPPPPV[` \x81R_a\x12\x14` \x83\x01\x84a\x14\x10V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x15\0W\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\x14\xCCV[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x15YW`\x1F\x19\x85\x84\x03\x01\x88Ra\x15C\x83\x83Qa\x14\x10V[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x15'V[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\x95W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x15\xD3`@\x87\x01\x82a\x15\x0BV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\x8BV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x15\0W\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x16\x02V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x16rW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x162V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\x95W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x16\xC8`@\x88\x01\x82a\x14\x10V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x16\xE3\x81\x83a\x16 V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16\xA2V[` \x81R_a\x12\x14` \x83\x01\x84a\x15\x0BV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\x95W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x17z`@\x87\x01\x82a\x16 V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x172V[\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\x12\x17Wa\x12\x17a\x17\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x02ta\x18\"\x83\x86a\x17\xFDV[\x84a\x17\xFDV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x18\x8C\xAC\xFCl\xA6\xB3\xAF*\xB1o\xAC\x03\xE4D\x1E5\x1A\xDFCS.\xD3\xDF\x83\xE2\n\xF4n\xBEdsolcC\0\x08\x1C\x003", + b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80c\x8C\x198a\x11a\0\xADW\x80c\xBAAO\xA6\x11a\0}W\x80c\xF9\xCE\x0EZ\x11a\0cW\x80c\xF9\xCE\x0EZ\x14a\x01\xF4W\x80c\xFAv&\xD4\x14a\x02\x07W\x80c\xFC\x0CTj\x14a\x02\x14W__\xFD[\x80c\xBAAO\xA6\x14a\x01\xD4W\x80c\xE2\x0C\x9Fq\x14a\x01\xECW__\xFD[\x80c\x8C\x198a\x14a\x01\xA7W\x80c\x91j\x17\xC6\x14a\x01\xAFW\x80c\xB0FO\xDC\x14a\x01\xC4W\x80c\xB5P\x8A\xA9\x14a\x01\xCCW__\xFD[\x80c?r\x86\xF4\x11a\0\xE8W\x80c?r\x86\xF4\x14a\x01^W\x80cf\xD9\xA9\xA0\x14a\x01fW\x80ck\xEDU\xA6\x14a\x01{W\x80c\x85\"l\x81\x14a\x01\x92W__\xFD[\x80c\n\x92T\xE4\x14a\x01\x19W\x80c\x1E\xD7\x83\x1C\x14a\x01#W\x80c*\xDE8\x80\x14a\x01AW\x80c>^<#\x14a\x01VW[__\xFD[a\x01!a\x02DV[\0[a\x01+a\x03\nV[`@Qa\x018\x91\x90a\x13\xBEV[`@Q\x80\x91\x03\x90\xF3[a\x01Ia\x03jV[`@Qa\x018\x91\x90a\x147V[a\x01+a\x04\xA6V[a\x01+a\x05\x04V[a\x01na\x05bV[`@Qa\x018\x91\x90a\x15zV[a\x01\x84` T\x81V[`@Q\x90\x81R` \x01a\x018V[a\x01\x9Aa\x06\xDBV[`@Qa\x018\x91\x90a\x15\xF8V[a\x01!a\x07\xA6V[a\x01\xB7a\r\rV[`@Qa\x018\x91\x90a\x16OV[a\x01\xB7a\x0E\x03V[a\x01\x9Aa\x0E\xF9V[a\x01\xDCa\x0F\xC4V[`@Q\x90\x15\x15\x81R` \x01a\x018V[a\x01+a\x10\x94V[a\x01!a\x02\x026`\x04a\x16\xE1V[a\x10\xF2V[`\x1FTa\x01\xDC\x90`\xFF\x16\x81V[`\x1FTa\x02,\x90a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x018V[a\x02}b\xD5\x9F\x80sJ\x1D\xF9qaG\xB7\x85\xF3\xF8 \x19\xF3o$\x8A\xC1]\xC3\x08s\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E` Ta\x10\xF2V[`\"T`!T`@Q`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x92\x90\x91\x16\x90a\x02\x9F\x90a\x13\xB1V[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x02\xCFW=__>=_\xFD[P`#\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`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03`W` \x02\x82\x01\x91\x90_R` _ \x90[\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03BW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\x86W\x83\x82\x90_R` _ \x01\x80Ta\x03\xFB\x90a\x17\"V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x04'\x90a\x17\"V[\x80\x15a\x04rW\x80`\x1F\x10a\x04IWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x04rV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x04UW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03\xDEV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x03\x8DV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03`W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03BWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03`W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03BWPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x05\xB5\x90a\x17\"V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05\xE1\x90a\x17\"V[\x80\x15a\x06,W\x80`\x1F\x10a\x06\x03Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x06,V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x06\x0FW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06\xC3W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x06pW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05\x85V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW\x83\x82\x90_R` _ \x01\x80Ta\x07\x1B\x90a\x17\"V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07G\x90a\x17\"V[\x80\x15a\x07\x92W\x80`\x1F\x10a\x07iWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07\x92V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07uW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x06\xFEV[`\x1FT`@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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R_\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x1EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08B\x91\x90a\x17sV[`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\xBBW__\xFD[PZ\xF1\x15\x80\x15a\x08\xCDW=__>=_\xFD[PP`\x1FT`#T` T`@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\x81R`\x01`\x01`\xA0\x1B\x03\x92\x83\x16`\x04\x82\x01R`$\x81\x01\x91\x90\x91Ra\x01\0\x90\x92\x04\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\tEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\ti\x91\x90a\x17\x8AV[P`#T`@Q\x7F\x86\xB9b\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\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x86\xB9b\r\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t\xD9W__\xFD[PZ\xF1\x15\x80\x15a\t\xEBW=__>=_\xFD[PP`\"T` \x80T`@\x80Q`\x01`\x01`\xA0\x1B\x03\x90\x94\x16\x84R\x91\x83\x01R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x93P\x01\x90P`@Q\x80\x91\x03\x90\xA1`#T`\x1FT` \x80T`@\x80Q\x92\x83\x01\x81R_\x83RQ\x7F\x7F\x81O5\0\0\0\0\0\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\x03a\x01\0\x90\x94\x04\x84\x16`\x04\x82\x01R`$\x81\x01\x91\x90\x91R`\x01`D\x82\x01R\x90Q`d\x82\x01R\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\n\xBFW__\xFD[PZ\xF1\x15\x80\x15a\n\xD1W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0B!W__\xFD[PZ\xF1\x15\x80\x15a\x0B3W=__>=_\xFD[PP`\"T`@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\x81R`\x01`\x04\x82\x01Ra\x0B\xC7\x93P`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0B\x9BW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\xBF\x91\x90a\x17sV[` Ta\x13.V[`\"T`#T`@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\x81R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x04\x82\x01Ra\x0CZ\x92\x91\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0C0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0CT\x91\x90a\x17sV[_a\x13.V[`\x1FT`@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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01Ra\r\n\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0C\xD4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\xF8\x91\x90a\x17sV[` Ta\r\x05\x90\x84a\x17\xB0V[a\x13.V[PV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\xEBW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\x98W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\r0V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0E\xE1W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0E\x8EW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0E&V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW\x83\x82\x90_R` _ \x01\x80Ta\x0F9\x90a\x17\"V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0Fe\x90a\x17\"V[\x80\x15a\x0F\xB0W\x80`\x1F\x10a\x0F\x87Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F\xB0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\x93W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0F\x1CV[`\x08T_\x90`\xFF\x16\x15a\x0F\xDBWP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10iW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\x8D\x91\x90a\x17sV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03`W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03BWPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\x8DW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x11\xB4\x91\x90\x81\x01\x90a\x18\x1BV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x11\xD2\x92\x91\x90a\x18\xCFV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11\xEEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\x12\x91\x90a\x17sV[P`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12~W__\xFD[PZ\xF1\x15\x80\x15a\x12\x90W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x13\x03W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13'\x91\x90a\x17\x8AV[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x13\x97W__\xFD[PZ\xFA\x15\x80\x15a\x13\xA9W=__>=_\xFD[PPPPPPV[a\r\xD2\x80a\x18\xF1\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x13\xFEW\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x13\xD7V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x12W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`\x01`\x01`\xA0\x1B\x03\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x14\xF8W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x14\xE2\x84\x86Qa\x14\tV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x14\xA8V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x14]V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x15pW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x150V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x12W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x15\xC6`@\x88\x01\x82a\x14\tV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x15\xE1\x81\x83a\x15\x1EV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\xA0V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x12W`?\x19\x87\x86\x03\x01\x84Ra\x16:\x85\x83Qa\x14\tV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16\x1EV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x12W`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x16\xB0`@\x87\x01\x82a\x15\x1EV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16uV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x16\xDCW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x16\xF4W__\xFD[\x845\x93Pa\x17\x04` \x86\x01a\x16\xC6V[\x92Pa\x17\x12`@\x86\x01a\x16\xC6V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x176W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x17mW\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17\x83W__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17\x9AW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x17\xA9W__\xFD[\x93\x92PPPV[\x81\x81\x03\x81\x81\x11\x15a\x17\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`\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x18+W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18AW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x18QW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18kWa\x18ka\x17\xEEV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x18\x9BWa\x18\x9Ba\x17\xEEV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x18\xB2W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x18\xE1`@\x83\x01\x85a\x14\tV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\xD28\x03\x80a\r\xD2\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\xF5a\0\xDD_9_\x81\x81`h\x01Ra\x02\x87\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xC1\x01R\x81\x81a\x03\x0F\x01R\x81\x81a\x03}\x01Ra\x04\xB8\x01Ra\x0C\xF5_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cPcL\x0E\x14a\0NW\x80cW\xED\xABN\x14a\0cW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xF3\xB9w\x84\x14a\0\xC6W[__\xFD[a\0aa\0\\6`\x04a\n{V[a\0\xEDV[\0[a\0\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\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\0aa\0\xC16`\x04a\x0B=V[a\x01\x17V[a\0\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\x81V[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\xC1V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x16V[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\xDAV[`@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\x83\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B\xE5V[\x82Q`@Q\x7F\x0E\xFEj\x8B\0\0\0\0\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`$\x82\x01\x88\x90R`D\x82\x01\x92\x90\x92R\x91\x92P_\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\x90\x91\x16\x90c\x0E\xFEj\x8B\x90`d\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02\xCFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xF3\x91\x90a\x0B\xE5V[\x90Pa\x036s\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\x83a\x06\xD5V[`@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_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\xC4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xE8\x91\x90a\x0B\xE5V[\x90P\x82\x81\x11a\x04>W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x04I\x84\x83a\x0C)V[\x85Q\x90\x91P\x81\x10\x15a\x04\x9DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x045V[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\xD4\x90\x85\x90\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\x90`\x84\x01[`@\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\x070V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06NW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06r\x91\x90a\x0B\xE5V[a\x06|\x91\x90a\x0CBV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\xD4\x90\x85\x90\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\x90`d\x01a\x05pV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07+\x90\x84\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\x90`d\x01a\x05pV[PPPV[_a\x07\x91\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\x08!\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07+W\x80\x80` \x01\x90Q\x81\x01\x90a\x07\xAF\x91\x90a\x0CUV[a\x07+W`@QbF\x1B\xCD`\xE5\x1B\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\x045V[``a\x08/\x84\x84_\x85a\x089V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\xB1W`@QbF\x1B\xCD`\xE5\x1B\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\x045V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\x15W`@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\x045V[__\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\t=\x91\x90a\x0CtV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\twW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t|V[``\x91P[P\x91P\x91Pa\t\x8C\x82\x82\x86a\t\x97V[\x97\x96PPPPPPPV[``\x83\x15a\t\xA6WP\x81a\x082V[\x82Q\x15a\t\xB6W\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x045\x91\x90a\x0C\x8AV[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\t\xF1W__\xFD[PV[\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\nDWa\nDa\t\xF4V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\nsWa\nsa\t\xF4V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\n\x8EW__\xFD[\x845a\n\x99\x81a\t\xD0V[\x93P` \x85\x015\x92P`@\x85\x015a\n\xB0\x81a\t\xD0V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xCBW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\xDBW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xF5Wa\n\xF5a\t\xF4V[a\x0B\x08` `\x1F\x19`\x1F\x84\x01\x16\x01a\nJV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0B\x1CW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0BQW__\xFD[\x855a\x0B\\\x81a\t\xD0V[\x94P` \x86\x015\x93P`@\x86\x015a\x0Bs\x81a\t\xD0V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0B\xA4W__\xFD[Pa\x0B\xADa\n!V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\xD2W__\xFD[Pa\x0B\xDBa\n!V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xF5W__\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[\x81\x81\x03\x81\x81\x11\x15a\x0C = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + tokenReceived: data.0, + amountOut: data.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.tokenReceived, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountOut), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 TokenOutput { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&TokenOutput> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. ```solidity event log(string); @@ -4038,13 +4120,30 @@ event logs(bytes); } } }; - /**Constructor`. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. ```solidity -constructor(); +function IS_TEST() external view returns (bool); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct constructorCall {} + pub struct IS_TESTCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IS_TESTReturn { + #[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 as alloy_sol_types; { @@ -4065,25 +4164,63 @@ constructor(); } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IS_TESTCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for constructorCall { + impl ::core::convert::From> for IS_TESTCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} + Self } } } - #[automatically_derived] - impl alloy_sol_types::SolConstructor for constructorCall { - type Parameters<'a> = (); - type Token<'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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IS_TESTReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IS_TESTReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for IS_TESTCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "IS_TEST()"; + const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -4094,25 +4231,55 @@ constructor(); fn tokenize(&self) -> Self::Token<'_> { () } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: IS_TESTReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: IS_TESTReturn = r.into(); + r._0 + }) + } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. + /**Function with signature `amountIn()` and selector `0x6bed55a6`. ```solidity -function IS_TEST() external view returns (bool); +function amountIn() external view returns (uint256); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct IS_TESTCall; + pub struct amountInCall; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. + ///Container type for the return parameters of the [`amountIn()`](amountInCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct IS_TESTReturn { + pub struct amountInReturn { #[allow(missing_docs)] - pub _0: bool, + pub _0: alloy::sol_types::private::primitives::aliases::U256, } #[allow( non_camel_case_types, @@ -4140,14 +4307,14 @@ function IS_TEST() external view returns (bool); } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: amountInCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { + impl ::core::convert::From> for amountInCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -4155,9 +4322,11 @@ function IS_TEST() external view returns (bool); } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (bool,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -4171,32 +4340,32 @@ function IS_TEST() external view returns (bool); } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: amountInReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { + impl ::core::convert::From> for amountInReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } } } #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { + impl alloy_sol_types::SolCall for amountInCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; + const SIGNATURE: &'static str = "amountIn()"; + const SELECTOR: [u8; 4] = [107u8, 237u8, 85u8, 166u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -4210,9 +4379,9 @@ function IS_TEST() external view returns (bool); #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { ( - ::tokenize( - ret, - ), + as alloy_sol_types::SolType>::tokenize(ret), ) } #[inline] @@ -4221,7 +4390,7 @@ function IS_TEST() external view returns (bool); '_, > as alloy_sol_types::SolType>::abi_decode_sequence(data) .map(|r| { - let r: IS_TESTReturn = r.into(); + let r: amountInReturn = r.into(); r._0 }) } @@ -4233,7 +4402,7 @@ function IS_TEST() external view returns (bool); '_, > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) .map(|r| { - let r: IS_TESTReturn = r.into(); + let r: amountInReturn = r.into(); r._0 }) } @@ -5018,31 +5187,17 @@ function failed() external view returns (bool); }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getBlockHeights(string,uint256,uint256)` and selector `0xfad06b8f`. + /**Function with signature `setUp()` and selector `0x0a9254e4`. ```solidity -function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); +function setUp() external; ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getBlockHeightsCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getBlockHeights(string,uint256,uint256)`](getBlockHeightsCall) function. + pub struct setUpCall; + ///Container type for the return parameters of the [`setUp()`](setUpCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getBlockHeightsReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >, - } + pub struct setUpReturn {} #[allow( non_camel_case_types, non_snake_case, @@ -5053,17 +5208,9 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte use alloy::sol_types as alloy_sol_types; { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - 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::String, - 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( @@ -5077,34 +5224,24 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsCall) -> Self { - (value.chainName, value.from, value.to) + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpCall) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getBlockHeightsCall { + impl ::core::convert::From> for setUpCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } + Self } } } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); + type UnderlyingSolTuple<'a> = (); #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >, - ); + type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -5118,42 +5255,39 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsReturn) -> Self { - (value.elements,) + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpReturn) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> - for getBlockHeightsReturn { + impl ::core::convert::From> for setUpReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } + Self {} } } } + impl setUpReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } #[automatically_derived] - impl alloy_sol_types::SolCall for getBlockHeightsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); + impl alloy_sol_types::SolCall for setUpCall { + type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); + type Return = setUpReturn; + type ReturnTuple<'a> = (); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getBlockHeights(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [250u8, 208u8, 107u8, 143u8]; + const SIGNATURE: &'static str = "setUp()"; + const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -5162,35 +5296,18 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte } #[inline] fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) + () } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) + setUpReturn::_tokenize(ret) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) + .map(Into::into) } #[inline] fn abi_decode_returns_validate( @@ -5199,40 +5316,32 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) + .map(Into::into) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getDigestLes(string,uint256,uint256)` and selector `0x44badbb6`. + /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. ```solidity -function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); +function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getDigestLesCall { + pub struct simulateForkAndTransferCall { + #[allow(missing_docs)] + pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, + pub sender: alloy::sol_types::private::Address, #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, + pub receiver: alloy::sol_types::private::Address, #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, + pub amount: alloy::sol_types::private::primitives::aliases::U256, } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getDigestLes(string,uint256,uint256)`](getDigestLesCall) function. + ///Container type for the return parameters of the [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getDigestLesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >, - } + pub struct simulateForkAndTransferReturn {} #[allow( non_camel_case_types, non_snake_case, @@ -5244,14 +5353,16 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa { #[doc(hidden)] 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::Uint<256>, ); #[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::primitives::aliases::U256, ); #[cfg(test)] @@ -5267,36 +5378,31 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesCall) -> Self { - (value.chainName, value.from, value.to) + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferCall) -> Self { + (value.forkAtBlock, value.sender, value.receiver, value.amount) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getDigestLesCall { + impl ::core::convert::From> + for simulateForkAndTransferCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, + forkAtBlock: tuple.0, + sender: tuple.1, + receiver: tuple.2, + amount: tuple.3, } } } } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array< - alloy::sol_types::sol_data::FixedBytes<32>, - >, - ); + type UnderlyingSolTuple<'a> = (); #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >, - ); + type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -5310,42 +5416,48 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesReturn) -> Self { - (value.elements,) + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferReturn) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getDigestLesReturn { + impl ::core::convert::From> + for simulateForkAndTransferReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } + Self {} } } } + impl simulateForkAndTransferReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } #[automatically_derived] - impl alloy_sol_types::SolCall for getDigestLesCall { + impl alloy_sol_types::SolCall for simulateForkAndTransferCall { type Parameters<'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::Uint<256>, ); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array< - alloy::sol_types::sol_data::FixedBytes<32>, - >, - ); + type Return = simulateForkAndTransferReturn; + type ReturnTuple<'a> = (); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getDigestLes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [68u8, 186u8, 219u8, 182u8]; + const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; + const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -5355,34 +5467,30 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - ::tokenize( - &self.chainName, - ), as alloy_sol_types::SolType>::tokenize(&self.from), + > as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), + ::tokenize( + &self.sender, + ), + ::tokenize( + &self.receiver, + ), as alloy_sol_types::SolType>::tokenize(&self.to), + > as alloy_sol_types::SolType>::tokenize(&self.amount), ) } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) + simulateForkAndTransferReturn::_tokenize(ret) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) + .map(Into::into) } #[inline] fn abi_decode_returns_validate( @@ -5391,37 +5499,29 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) + .map(Into::into) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaderHexes(string,uint256,uint256)` and selector `0x0813852a`. + /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. ```solidity -function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); +function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getHeaderHexesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } + pub struct targetArtifactSelectorsCall; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaderHexes(string,uint256,uint256)`](getHeaderHexesCall) function. + ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getHeaderHexesReturn { + pub struct targetArtifactSelectorsReturn { #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec, + pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, } #[allow( non_camel_case_types, @@ -5433,17 +5533,9 @@ function getHeaderHexes(string memory chainName, uint256 from, uint256 to) exter use alloy::sol_types as alloy_sol_types; { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - 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::String, - 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( @@ -5457,31 +5549,31 @@ function getHeaderHexes(string memory chainName, uint256 from, uint256 to) exter } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesCall) -> Self { - (value.chainName, value.from, value.to) + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactSelectorsCall) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getHeaderHexesCall { + impl ::core::convert::From> + for targetArtifactSelectorsCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } + Self } } } { #[doc(hidden)] type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array, ); #[doc(hidden)] type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, + alloy::sol_types::private::Vec< + ::RustType, + >, ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] @@ -5496,42 +5588,40 @@ function getHeaderHexes(string memory chainName, uint256 from, uint256 to) exter } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesReturn) -> Self { - (value.elements,) + fn from(value: targetArtifactSelectorsReturn) -> Self { + (value.targetedArtifactSelectors_,) } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for getHeaderHexesReturn { + for targetArtifactSelectorsReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } + Self { + targetedArtifactSelectors_: tuple.0, + } } } } #[automatically_derived] - impl alloy_sol_types::SolCall for getHeaderHexesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); + impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { + type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Bytes, + ::RustType, >; type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array, ); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaderHexes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [8u8, 19u8, 133u8, 42u8]; + const SIGNATURE: &'static str = "targetArtifactSelectors()"; + const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -5540,23 +5630,13 @@ function getHeaderHexes(string memory chainName, uint256 from, uint256 to) exter } #[inline] fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) + () } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { ( as alloy_sol_types::SolType>::tokenize(ret), ) } @@ -5566,8 +5646,8 @@ function getHeaderHexes(string memory chainName, uint256 from, uint256 to) exter '_, > as alloy_sol_types::SolType>::abi_decode_sequence(data) .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ }) } #[inline] @@ -5578,36 +5658,31 @@ function getHeaderHexes(string memory chainName, uint256 from, uint256 to) exter '_, > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ }) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaders(string,uint256,uint256)` and selector `0x1c0da81f`. + /**Function with signature `targetArtifacts()` and selector `0x85226c81`. ```solidity -function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); +function targetArtifacts() external view returns (string[] memory targetedArtifacts_); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getHeadersCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } + pub struct targetArtifactsCall; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaders(string,uint256,uint256)`](getHeadersCall) function. + ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getHeadersReturn { + pub struct targetArtifactsReturn { #[allow(missing_docs)] - pub headers: alloy::sol_types::private::Bytes, + pub targetedArtifacts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >, } #[allow( non_camel_case_types, @@ -5619,17 +5694,9 @@ function getHeaders(string memory chainName, uint256 from, uint256 to) external use alloy::sol_types as alloy_sol_types; { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - 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::String, - 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( @@ -5643,28 +5710,28 @@ function getHeaders(string memory chainName, uint256 from, uint256 to) external } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersCall) -> Self { - (value.chainName, value.from, value.to) + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsCall) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getHeadersCall { + impl ::core::convert::From> for targetArtifactsCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } + Self } } } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Bytes,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -5678,36 +5745,40 @@ function getHeaders(string memory chainName, uint256 from, uint256 to) external } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersReturn) -> Self { - (value.headers,) + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsReturn) -> Self { + (value.targetedArtifacts_,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getHeadersReturn { + impl ::core::convert::From> + for targetArtifactsReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { headers: tuple.0 } + Self { + targetedArtifacts_: tuple.0, + } } } } #[automatically_derived] - impl alloy_sol_types::SolCall for getHeadersCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); + impl alloy_sol_types::SolCall for targetArtifactsCall { + type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Bytes; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaders(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [28u8, 13u8, 168u8, 31u8]; + const SIGNATURE: &'static str = "targetArtifacts()"; + const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -5716,24 +5787,14 @@ function getHeaders(string memory chainName, uint256 from, uint256 to) external } #[inline] fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) + () } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { ( - ::tokenize( - ret, - ), + as alloy_sol_types::SolType>::tokenize(ret), ) } #[inline] @@ -5742,8 +5803,8 @@ function getHeaders(string memory chainName, uint256 from, uint256 to) external '_, > as alloy_sol_types::SolType>::abi_decode_sequence(data) .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ }) } #[inline] @@ -5754,30 +5815,30 @@ function getHeaders(string memory chainName, uint256 from, uint256 to) external '_, > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ }) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. + /**Function with signature `targetContracts()` and selector `0x3f7286f4`. ```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); +function targetContracts() external view returns (address[] memory targetedContracts_); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetArtifactSelectorsCall; + pub struct targetContractsCall; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. + ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { + pub struct targetContractsReturn { #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, + pub targetedContracts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, >, } #[allow( @@ -5806,16 +5867,14 @@ function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtif } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetContractsCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { + impl ::core::convert::From> for targetContractsCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -5824,13 +5883,11 @@ function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtif { #[doc(hidden)] type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array, ); #[doc(hidden)] type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, + alloy::sol_types::private::Vec, ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] @@ -5845,40 +5902,40 @@ function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtif } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) + fn from(value: targetContractsReturn) -> Self { + (value.targetedContracts_,) } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for targetArtifactSelectorsReturn { + for targetContractsReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { - targetedArtifactSelectors_: tuple.0, + targetedContracts_: tuple.0, } } } } #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { + impl alloy_sol_types::SolCall for targetContractsCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = alloy::sol_types::private::Vec< - ::RustType, + alloy::sol_types::private::Address, >; type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array, ); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; + const SIGNATURE: &'static str = "targetContracts()"; + const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -5893,7 +5950,7 @@ function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtif fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { ( as alloy_sol_types::SolType>::tokenize(ret), ) } @@ -5903,8 +5960,8 @@ function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtif '_, > as alloy_sol_types::SolType>::abi_decode_sequence(data) .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ + let r: targetContractsReturn = r.into(); + r.targetedContracts_ }) } #[inline] @@ -5915,30 +5972,30 @@ function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtif '_, > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ + let r: targetContractsReturn = r.into(); + r.targetedContracts_ }) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. + /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. ```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); +function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetArtifactsCall; + pub struct targetInterfacesCall; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. + ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetArtifactsReturn { + pub struct targetInterfacesReturn { #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, + pub targetedInterfaces_: alloy::sol_types::private::Vec< + ::RustType, >, } #[allow( @@ -5967,14 +6024,16 @@ function targetArtifacts() external view returns (string[] memory targetedArtifa } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetInterfacesCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { + impl ::core::convert::From> + for targetInterfacesCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -5983,11 +6042,13 @@ function targetArtifacts() external view returns (string[] memory targetedArtifa { #[doc(hidden)] type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array, ); #[doc(hidden)] type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, + alloy::sol_types::private::Vec< + ::RustType, + >, ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] @@ -6002,40 +6063,40 @@ function targetArtifacts() external view returns (string[] memory targetedArtifa } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) + fn from(value: targetInterfacesReturn) -> Self { + (value.targetedInterfaces_,) } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for targetArtifactsReturn { + for targetInterfacesReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { - targetedArtifacts_: tuple.0, + targetedInterfaces_: tuple.0, } } } } #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { + impl alloy_sol_types::SolCall for targetInterfacesCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, + ::RustType, >; type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array, ); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; + const SIGNATURE: &'static str = "targetInterfaces()"; + const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -6050,7 +6111,7 @@ function targetArtifacts() external view returns (string[] memory targetedArtifa fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { ( as alloy_sol_types::SolType>::tokenize(ret), ) } @@ -6060,8 +6121,8 @@ function targetArtifacts() external view returns (string[] memory targetedArtifa '_, > as alloy_sol_types::SolType>::abi_decode_sequence(data) .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ }) } #[inline] @@ -6072,30 +6133,30 @@ function targetArtifacts() external view returns (string[] memory targetedArtifa '_, > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ }) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. + /**Function with signature `targetSelectors()` and selector `0x916a17c6`. ```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); +function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetContractsCall; + pub struct targetSelectorsCall; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. + ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetContractsReturn { + pub struct targetSelectorsReturn { #[allow(missing_docs)] - pub targetedContracts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, + pub targetedSelectors_: alloy::sol_types::private::Vec< + ::RustType, >, } #[allow( @@ -6124,14 +6185,14 @@ function targetContracts() external view returns (address[] memory targetedContr } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSelectorsCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { + impl ::core::convert::From> for targetSelectorsCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -6140,11 +6201,13 @@ function targetContracts() external view returns (address[] memory targetedContr { #[doc(hidden)] type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array, ); #[doc(hidden)] type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, + alloy::sol_types::private::Vec< + ::RustType, + >, ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] @@ -6159,40 +6222,40 @@ function targetContracts() external view returns (address[] memory targetedContr } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) + fn from(value: targetSelectorsReturn) -> Self { + (value.targetedSelectors_,) } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for targetContractsReturn { + for targetSelectorsReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { - targetedContracts_: tuple.0, + targetedSelectors_: tuple.0, } } } } #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { + impl alloy_sol_types::SolCall for targetSelectorsCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, + ::RustType, >; type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array, ); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; + const SIGNATURE: &'static str = "targetSelectors()"; + const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -6207,7 +6270,7 @@ function targetContracts() external view returns (address[] memory targetedContr fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { ( as alloy_sol_types::SolType>::tokenize(ret), ) } @@ -6217,8 +6280,8 @@ function targetContracts() external view returns (address[] memory targetedContr '_, > as alloy_sol_types::SolType>::abi_decode_sequence(data) .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ }) } #[inline] @@ -6229,30 +6292,30 @@ function targetContracts() external view returns (address[] memory targetedContr '_, > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ }) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. + /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. ```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); +function targetSenders() external view returns (address[] memory targetedSenders_); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetInterfacesCall; + pub struct targetSendersCall; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. + ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetInterfacesReturn { + pub struct targetSendersReturn { #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, + pub targetedSenders_: alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, >, } #[allow( @@ -6281,16 +6344,14 @@ function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { + impl ::core::convert::From> for targetSendersCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -6299,13 +6360,11 @@ function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] { #[doc(hidden)] type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array, ); #[doc(hidden)] type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, + alloy::sol_types::private::Vec, ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] @@ -6320,40 +6379,36 @@ function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersReturn) -> Self { + (value.targetedSenders_,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { + impl ::core::convert::From> for targetSendersReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } + Self { targetedSenders_: tuple.0 } } } } #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { + impl alloy_sol_types::SolCall for targetSendersCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = alloy::sol_types::private::Vec< - ::RustType, + alloy::sol_types::private::Address, >; type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array, ); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; + const SIGNATURE: &'static str = "targetSenders()"; + const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -6368,7 +6423,7 @@ function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { ( as alloy_sol_types::SolType>::tokenize(ret), ) } @@ -6378,8 +6433,8 @@ function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] '_, > as alloy_sol_types::SolType>::abi_decode_sequence(data) .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ + let r: targetSendersReturn = r.into(); + r.targetedSenders_ }) } #[inline] @@ -6390,32 +6445,25 @@ function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] '_, > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ + let r: targetSendersReturn = r.into(); + r.targetedSenders_ }) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. + /**Function with signature `testDepositToVault()` and selector `0x8c193861`. ```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); +function testDepositToVault() external; ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. + pub struct testDepositToVaultCall; + ///Container type for the return parameters of the [`testDepositToVault()`](testDepositToVaultCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } + pub struct testDepositToVaultReturn {} #[allow( non_camel_case_types, non_snake_case, @@ -6442,14 +6490,16 @@ function targetSelectors() external view returns (StdInvariant.FuzzSelector[] me } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: testDepositToVaultCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { + impl ::core::convert::From> + for testDepositToVaultCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -6457,15 +6507,9 @@ function targetSelectors() external view returns (StdInvariant.FuzzSelector[] me } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); + type UnderlyingSolTuple<'a> = (); #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); + type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -6479,40 +6523,41 @@ function targetSelectors() external view returns (StdInvariant.FuzzSelector[] me } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) + fn from(value: testDepositToVaultReturn) -> Self { + () } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for targetSelectorsReturn { + for testDepositToVaultReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } + Self {} } } } + impl testDepositToVaultReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { + impl alloy_sol_types::SolCall for testDepositToVaultCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); + type Return = testDepositToVaultReturn; + type ReturnTuple<'a> = (); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; + const SIGNATURE: &'static str = "testDepositToVault()"; + const SELECTOR: [u8; 4] = [140u8, 25u8, 56u8, 97u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -6525,21 +6570,14 @@ function targetSelectors() external view returns (StdInvariant.FuzzSelector[] me } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) + testDepositToVaultReturn::_tokenize(ret) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) + .map(Into::into) } #[inline] fn abi_decode_returns_validate( @@ -6548,32 +6586,27 @@ function targetSelectors() external view returns (StdInvariant.FuzzSelector[] me as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) + .map(Into::into) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. + /**Function with signature `token()` and selector `0xfc0c546a`. ```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); +function token() external view returns (address); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetSendersCall; + pub struct tokenCall; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. + ///Container type for the return parameters of the [`token()`](tokenCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetSendersReturn { + pub struct tokenReturn { #[allow(missing_docs)] - pub targetedSenders_: alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >, + pub _0: alloy::sol_types::private::Address, } #[allow( non_camel_case_types, @@ -6601,14 +6634,14 @@ function targetSenders() external view returns (address[] memory targetedSenders } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { + impl ::core::convert::From> for tokenCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -6616,13 +6649,9 @@ function targetSenders() external view returns (address[] memory targetedSenders } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -6636,36 +6665,32 @@ function targetSenders() external view returns (address[] memory targetedSenders } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenReturn) -> Self { + (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { + impl ::core::convert::From> for tokenReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } + Self { _0: tuple.0 } } } } #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { + impl alloy_sol_types::SolCall for tokenCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; + const SIGNATURE: &'static str = "token()"; + const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -6679,9 +6704,9 @@ function targetSenders() external view returns (address[] memory targetedSenders #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { ( - as alloy_sol_types::SolType>::tokenize(ret), + ::tokenize( + ret, + ), ) } #[inline] @@ -6690,8 +6715,8 @@ function targetSenders() external view returns (address[] memory targetedSenders '_, > as alloy_sol_types::SolType>::abi_decode_sequence(data) .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ + let r: tokenReturn = r.into(); + r._0 }) } #[inline] @@ -6702,19 +6727,21 @@ function targetSenders() external view returns (address[] memory targetedSenders '_, > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ + let r: tokenReturn = r.into(); + r._0 }) } } }; - ///Container for all the [`FullRelayWithVerifyTest`](self) function calls. + ///Container for all the [`HybridBTCStrategyForkedWbtc`](self) function calls. #[derive(serde::Serialize, serde::Deserialize)] #[derive()] - pub enum FullRelayWithVerifyTestCalls { + pub enum HybridBTCStrategyForkedWbtcCalls { #[allow(missing_docs)] IS_TEST(IS_TESTCall), #[allow(missing_docs)] + amountIn(amountInCall), + #[allow(missing_docs)] excludeArtifacts(excludeArtifactsCall), #[allow(missing_docs)] excludeContracts(excludeContractsCall), @@ -6725,13 +6752,9 @@ function targetSenders() external view returns (address[] memory targetedSenders #[allow(missing_docs)] failed(failedCall), #[allow(missing_docs)] - getBlockHeights(getBlockHeightsCall), - #[allow(missing_docs)] - getDigestLes(getDigestLesCall), + setUp(setUpCall), #[allow(missing_docs)] - getHeaderHexes(getHeaderHexesCall), - #[allow(missing_docs)] - getHeaders(getHeadersCall), + simulateForkAndTransfer(simulateForkAndTransferCall), #[allow(missing_docs)] targetArtifactSelectors(targetArtifactSelectorsCall), #[allow(missing_docs)] @@ -6744,9 +6767,13 @@ function targetSenders() external view returns (address[] memory targetedSenders targetSelectors(targetSelectorsCall), #[allow(missing_docs)] targetSenders(targetSendersCall), + #[allow(missing_docs)] + testDepositToVault(testDepositToVaultCall), + #[allow(missing_docs)] + token(tokenCall), } #[automatically_derived] - impl FullRelayWithVerifyTestCalls { + impl HybridBTCStrategyForkedWbtcCalls { /// All the selectors of this enum. /// /// Note that the selectors might not be in the same order as the variants. @@ -6754,33 +6781,35 @@ function targetSenders() external view returns (address[] memory targetedSenders /// /// Prefer using `SolInterface` methods instead. pub const SELECTORS: &'static [[u8; 4usize]] = &[ - [8u8, 19u8, 133u8, 42u8], - [28u8, 13u8, 168u8, 31u8], + [10u8, 146u8, 84u8, 228u8], [30u8, 215u8, 131u8, 28u8], [42u8, 222u8, 56u8, 128u8], [62u8, 94u8, 60u8, 35u8], [63u8, 114u8, 134u8, 244u8], - [68u8, 186u8, 219u8, 182u8], [102u8, 217u8, 169u8, 160u8], + [107u8, 237u8, 85u8, 166u8], [133u8, 34u8, 108u8, 129u8], + [140u8, 25u8, 56u8, 97u8], [145u8, 106u8, 23u8, 198u8], [176u8, 70u8, 79u8, 220u8], [181u8, 80u8, 138u8, 169u8], [186u8, 65u8, 79u8, 166u8], [226u8, 12u8, 159u8, 113u8], + [249u8, 206u8, 14u8, 90u8], [250u8, 118u8, 38u8, 212u8], - [250u8, 208u8, 107u8, 143u8], + [252u8, 12u8, 84u8, 106u8], ]; } #[automatically_derived] - impl alloy_sol_types::SolInterface for FullRelayWithVerifyTestCalls { - const NAME: &'static str = "FullRelayWithVerifyTestCalls"; + impl alloy_sol_types::SolInterface for HybridBTCStrategyForkedWbtcCalls { + const NAME: &'static str = "HybridBTCStrategyForkedWbtcCalls"; const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 16usize; + const COUNT: usize = 17usize; #[inline] fn selector(&self) -> [u8; 4] { match self { Self::IS_TEST(_) => ::SELECTOR, + Self::amountIn(_) => ::SELECTOR, Self::excludeArtifacts(_) => { ::SELECTOR } @@ -6794,17 +6823,9 @@ function targetSenders() external view returns (address[] memory targetedSenders ::SELECTOR } Self::failed(_) => ::SELECTOR, - Self::getBlockHeights(_) => { - ::SELECTOR - } - Self::getDigestLes(_) => { - ::SELECTOR - } - Self::getHeaderHexes(_) => { - ::SELECTOR - } - Self::getHeaders(_) => { - ::SELECTOR + Self::setUp(_) => ::SELECTOR, + Self::simulateForkAndTransfer(_) => { + ::SELECTOR } Self::targetArtifactSelectors(_) => { ::SELECTOR @@ -6824,6 +6845,10 @@ function targetSenders() external view returns (address[] memory targetedSenders Self::targetSenders(_) => { ::SELECTOR } + Self::testDepositToVault(_) => { + ::SELECTOR + } + Self::token(_) => ::SELECTOR, } } #[inline] @@ -6842,178 +6867,187 @@ function targetSenders() external view returns (address[] memory targetedSenders ) -> alloy_sol_types::Result { static DECODE_SHIMS: &[fn( &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayWithVerifyTestCalls::getHeaderHexes) - } - getHeaderHexes - }, + ) -> alloy_sol_types::Result] = &[ { - fn getHeaders( + fn setUp( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayWithVerifyTestCalls::getHeaders) + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(HybridBTCStrategyForkedWbtcCalls::setUp) } - getHeaders + setUp }, { fn excludeSenders( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayWithVerifyTestCalls::excludeSenders) + .map(HybridBTCStrategyForkedWbtcCalls::excludeSenders) } excludeSenders }, { fn targetInterfaces( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayWithVerifyTestCalls::targetInterfaces) + .map(HybridBTCStrategyForkedWbtcCalls::targetInterfaces) } targetInterfaces }, { fn targetSenders( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayWithVerifyTestCalls::targetSenders) + .map(HybridBTCStrategyForkedWbtcCalls::targetSenders) } targetSenders }, { fn targetContracts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayWithVerifyTestCalls::targetContracts) + .map(HybridBTCStrategyForkedWbtcCalls::targetContracts) } targetContracts }, { - fn getDigestLes( + fn targetArtifactSelectors( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( + ) -> alloy_sol_types::Result { + ::abi_decode_raw( data, ) - .map(FullRelayWithVerifyTestCalls::getDigestLes) + .map( + HybridBTCStrategyForkedWbtcCalls::targetArtifactSelectors, + ) } - getDigestLes + targetArtifactSelectors }, { - fn targetArtifactSelectors( + fn amountIn( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayWithVerifyTestCalls::targetArtifactSelectors) + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(HybridBTCStrategyForkedWbtcCalls::amountIn) } - targetArtifactSelectors + amountIn }, { fn targetArtifacts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayWithVerifyTestCalls::targetArtifacts) + .map(HybridBTCStrategyForkedWbtcCalls::targetArtifacts) } targetArtifacts }, + { + fn testDepositToVault( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(HybridBTCStrategyForkedWbtcCalls::testDepositToVault) + } + testDepositToVault + }, { fn targetSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayWithVerifyTestCalls::targetSelectors) + .map(HybridBTCStrategyForkedWbtcCalls::targetSelectors) } targetSelectors }, { fn excludeSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayWithVerifyTestCalls::excludeSelectors) + .map(HybridBTCStrategyForkedWbtcCalls::excludeSelectors) } excludeSelectors }, { fn excludeArtifacts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayWithVerifyTestCalls::excludeArtifacts) + .map(HybridBTCStrategyForkedWbtcCalls::excludeArtifacts) } excludeArtifacts }, { fn failed( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw(data) - .map(FullRelayWithVerifyTestCalls::failed) + .map(HybridBTCStrategyForkedWbtcCalls::failed) } failed }, { fn excludeContracts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayWithVerifyTestCalls::excludeContracts) + .map(HybridBTCStrategyForkedWbtcCalls::excludeContracts) } excludeContracts }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + HybridBTCStrategyForkedWbtcCalls::simulateForkAndTransfer, + ) + } + simulateForkAndTransfer + }, { fn IS_TEST( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw(data) - .map(FullRelayWithVerifyTestCalls::IS_TEST) + .map(HybridBTCStrategyForkedWbtcCalls::IS_TEST) } IS_TEST }, { - fn getBlockHeights( + fn token( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayWithVerifyTestCalls::getBlockHeights) + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(HybridBTCStrategyForkedWbtcCalls::token) } - getBlockHeights + token }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { @@ -7034,182 +7068,197 @@ function targetSenders() external view returns (address[] memory targetedSenders ) -> alloy_sol_types::Result { static DECODE_VALIDATE_SHIMS: &[fn( &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayWithVerifyTestCalls::getHeaderHexes) - } - getHeaderHexes - }, + ) -> alloy_sol_types::Result] = &[ { - fn getHeaders( + fn setUp( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( data, ) - .map(FullRelayWithVerifyTestCalls::getHeaders) + .map(HybridBTCStrategyForkedWbtcCalls::setUp) } - getHeaders + setUp }, { fn excludeSenders( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayWithVerifyTestCalls::excludeSenders) + .map(HybridBTCStrategyForkedWbtcCalls::excludeSenders) } excludeSenders }, { fn targetInterfaces( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayWithVerifyTestCalls::targetInterfaces) + .map(HybridBTCStrategyForkedWbtcCalls::targetInterfaces) } targetInterfaces }, { fn targetSenders( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayWithVerifyTestCalls::targetSenders) + .map(HybridBTCStrategyForkedWbtcCalls::targetSenders) } targetSenders }, { fn targetContracts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayWithVerifyTestCalls::targetContracts) + .map(HybridBTCStrategyForkedWbtcCalls::targetContracts) } targetContracts }, { - fn getDigestLes( + fn targetArtifactSelectors( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( data, ) - .map(FullRelayWithVerifyTestCalls::getDigestLes) + .map( + HybridBTCStrategyForkedWbtcCalls::targetArtifactSelectors, + ) } - getDigestLes + targetArtifactSelectors }, { - fn targetArtifactSelectors( + fn amountIn( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( data, ) - .map(FullRelayWithVerifyTestCalls::targetArtifactSelectors) + .map(HybridBTCStrategyForkedWbtcCalls::amountIn) } - targetArtifactSelectors + amountIn }, { fn targetArtifacts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayWithVerifyTestCalls::targetArtifacts) + .map(HybridBTCStrategyForkedWbtcCalls::targetArtifacts) } targetArtifacts }, + { + fn testDepositToVault( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(HybridBTCStrategyForkedWbtcCalls::testDepositToVault) + } + testDepositToVault + }, { fn targetSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayWithVerifyTestCalls::targetSelectors) + .map(HybridBTCStrategyForkedWbtcCalls::targetSelectors) } targetSelectors }, { fn excludeSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayWithVerifyTestCalls::excludeSelectors) + .map(HybridBTCStrategyForkedWbtcCalls::excludeSelectors) } excludeSelectors }, { fn excludeArtifacts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayWithVerifyTestCalls::excludeArtifacts) + .map(HybridBTCStrategyForkedWbtcCalls::excludeArtifacts) } excludeArtifacts }, { fn failed( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayWithVerifyTestCalls::failed) + .map(HybridBTCStrategyForkedWbtcCalls::failed) } failed }, { fn excludeContracts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayWithVerifyTestCalls::excludeContracts) + .map(HybridBTCStrategyForkedWbtcCalls::excludeContracts) } excludeContracts }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + HybridBTCStrategyForkedWbtcCalls::simulateForkAndTransfer, + ) + } + simulateForkAndTransfer + }, { fn IS_TEST( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayWithVerifyTestCalls::IS_TEST) + .map(HybridBTCStrategyForkedWbtcCalls::IS_TEST) } IS_TEST }, { - fn getBlockHeights( + fn token( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( data, ) - .map(FullRelayWithVerifyTestCalls::getBlockHeights) + .map(HybridBTCStrategyForkedWbtcCalls::token) } - getBlockHeights + token }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { @@ -7228,6 +7277,9 @@ function targetSenders() external view returns (address[] memory targetedSenders Self::IS_TEST(inner) => { ::abi_encoded_size(inner) } + Self::amountIn(inner) => { + ::abi_encoded_size(inner) + } Self::excludeArtifacts(inner) => { ::abi_encoded_size( inner, @@ -7251,24 +7303,14 @@ function targetSenders() external view returns (address[] memory targetedSenders Self::failed(inner) => { ::abi_encoded_size(inner) } - Self::getBlockHeights(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getDigestLes(inner) => { - ::abi_encoded_size( - inner, - ) + Self::setUp(inner) => { + ::abi_encoded_size(inner) } - Self::getHeaderHexes(inner) => { - ::abi_encoded_size( + Self::simulateForkAndTransfer(inner) => { + ::abi_encoded_size( inner, ) } - Self::getHeaders(inner) => { - ::abi_encoded_size(inner) - } Self::targetArtifactSelectors(inner) => { ::abi_encoded_size( inner, @@ -7299,6 +7341,14 @@ function targetSenders() external view returns (address[] memory targetedSenders inner, ) } + Self::testDepositToVault(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::token(inner) => { + ::abi_encoded_size(inner) + } } } #[inline] @@ -7307,6 +7357,12 @@ function targetSenders() external view returns (address[] memory targetedSenders Self::IS_TEST(inner) => { ::abi_encode_raw(inner, out) } + Self::amountIn(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } Self::excludeArtifacts(inner) => { ::abi_encode_raw( inner, @@ -7334,26 +7390,11 @@ function targetSenders() external view returns (address[] memory targetedSenders Self::failed(inner) => { ::abi_encode_raw(inner, out) } - Self::getBlockHeights(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getDigestLes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encode_raw( - inner, - out, - ) + Self::setUp(inner) => { + ::abi_encode_raw(inner, out) } - Self::getHeaders(inner) => { - ::abi_encode_raw( + Self::simulateForkAndTransfer(inner) => { + ::abi_encode_raw( inner, out, ) @@ -7394,13 +7435,24 @@ function targetSenders() external view returns (address[] memory targetedSenders out, ) } + Self::testDepositToVault(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::token(inner) => { + ::abi_encode_raw(inner, out) + } } } } - ///Container for all the [`FullRelayWithVerifyTest`](self) events. + ///Container for all the [`HybridBTCStrategyForkedWbtc`](self) events. #[derive(serde::Serialize, serde::Deserialize)] #[derive()] - pub enum FullRelayWithVerifyTestEvents { + pub enum HybridBTCStrategyForkedWbtcEvents { + #[allow(missing_docs)] + TokenOutput(TokenOutput), #[allow(missing_docs)] log(log), #[allow(missing_docs)] @@ -7447,7 +7499,7 @@ function targetSenders() external view returns (address[] memory targetedSenders logs(logs), } #[automatically_derived] - impl FullRelayWithVerifyTestEvents { + impl HybridBTCStrategyForkedWbtcEvents { /// All the selectors of this enum. /// /// Note that the selectors might not be in the same order as the variants. @@ -7465,6 +7517,11 @@ function targetSenders() external view returns (address[] memory targetedSenders 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, ], + [ + 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ], [ 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, @@ -7568,14 +7625,21 @@ function targetSenders() external view returns (address[] memory targetedSenders ]; } #[automatically_derived] - impl alloy_sol_types::SolEventInterface for FullRelayWithVerifyTestEvents { - const NAME: &'static str = "FullRelayWithVerifyTestEvents"; - const COUNT: usize = 22usize; + impl alloy_sol_types::SolEventInterface for HybridBTCStrategyForkedWbtcEvents { + const NAME: &'static str = "HybridBTCStrategyForkedWbtcEvents"; + const COUNT: usize = 23usize; fn decode_raw_log( topics: &[alloy_sol_types::Word], data: &[u8], ) -> alloy_sol_types::Result { match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::TokenOutput) + } Some(::SIGNATURE_HASH) => { ::decode_raw_log(topics, data) .map(Self::log) @@ -7747,9 +7811,12 @@ function targetSenders() external view returns (address[] memory targetedSenders } } #[automatically_derived] - impl alloy_sol_types::private::IntoLogData for FullRelayWithVerifyTestEvents { + impl alloy_sol_types::private::IntoLogData for HybridBTCStrategyForkedWbtcEvents { fn to_log_data(&self) -> alloy_sol_types::private::LogData { match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } Self::log(inner) => { alloy_sol_types::private::IntoLogData::to_log_data(inner) } @@ -7820,6 +7887,9 @@ function targetSenders() external view returns (address[] memory targetedSenders } fn into_log_data(self) -> alloy_sol_types::private::LogData { match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } Self::log(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) } @@ -7890,9 +7960,9 @@ function targetSenders() external view returns (address[] memory targetedSenders } } use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`FullRelayWithVerifyTest`](self) contract instance. + /**Creates a new wrapper around an on-chain [`HybridBTCStrategyForkedWbtc`](self) contract instance. -See the [wrapper's documentation](`FullRelayWithVerifyTestInstance`) for more details.*/ +See the [wrapper's documentation](`HybridBTCStrategyForkedWbtcInstance`) for more details.*/ #[inline] pub const fn new< P: alloy_contract::private::Provider, @@ -7900,8 +7970,8 @@ See the [wrapper's documentation](`FullRelayWithVerifyTestInstance`) for more de >( address: alloy_sol_types::private::Address, provider: P, - ) -> FullRelayWithVerifyTestInstance { - FullRelayWithVerifyTestInstance::::new(address, provider) + ) -> HybridBTCStrategyForkedWbtcInstance { + HybridBTCStrategyForkedWbtcInstance::::new(address, provider) } /**Deploys this contract using the given `provider` and constructor arguments, if any. @@ -7915,9 +7985,9 @@ For more fine-grained control over the deployment process, use [`deploy_builder` >( provider: P, ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, + Output = alloy_contract::Result>, > { - FullRelayWithVerifyTestInstance::::deploy(provider) + HybridBTCStrategyForkedWbtcInstance::::deploy(provider) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` and constructor arguments, if any. @@ -7929,12 +7999,12 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ P: alloy_contract::private::Provider, N: alloy_contract::private::Network, >(provider: P) -> alloy_contract::RawCallBuilder { - FullRelayWithVerifyTestInstance::::deploy_builder(provider) + HybridBTCStrategyForkedWbtcInstance::::deploy_builder(provider) } - /**A [`FullRelayWithVerifyTest`](self) instance. + /**A [`HybridBTCStrategyForkedWbtc`](self) instance. Contains type-safe methods for interacting with an on-chain instance of the -[`FullRelayWithVerifyTest`](self) contract located at a given `address`, using a given +[`HybridBTCStrategyForkedWbtc`](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!) @@ -7943,7 +8013,7 @@ 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 FullRelayWithVerifyTestInstance< + pub struct HybridBTCStrategyForkedWbtcInstance< P, N = alloy_contract::private::Ethereum, > { @@ -7952,10 +8022,10 @@ See the [module-level documentation](self) for all the available methods.*/ _network: ::core::marker::PhantomData, } #[automatically_derived] - impl ::core::fmt::Debug for FullRelayWithVerifyTestInstance { + impl ::core::fmt::Debug for HybridBTCStrategyForkedWbtcInstance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("FullRelayWithVerifyTestInstance") + f.debug_tuple("HybridBTCStrategyForkedWbtcInstance") .field(&self.address) .finish() } @@ -7965,10 +8035,10 @@ See the [module-level documentation](self) for all the available methods.*/ impl< P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - > FullRelayWithVerifyTestInstance { - /**Creates a new wrapper around an on-chain [`FullRelayWithVerifyTest`](self) contract instance. + > HybridBTCStrategyForkedWbtcInstance { + /**Creates a new wrapper around an on-chain [`HybridBTCStrategyForkedWbtc`](self) contract instance. -See the [wrapper's documentation](`FullRelayWithVerifyTestInstance`) for more details.*/ +See the [wrapper's documentation](`HybridBTCStrategyForkedWbtcInstance`) for more details.*/ #[inline] pub const fn new( address: alloy_sol_types::private::Address, @@ -7988,7 +8058,7 @@ For more fine-grained control over the deployment process, use [`deploy_builder` #[inline] pub async fn deploy( provider: P, - ) -> alloy_contract::Result> { + ) -> alloy_contract::Result> { let call_builder = Self::deploy_builder(provider); let contract_address = call_builder.deploy().await?; Ok(Self::new(contract_address, call_builder.provider)) @@ -8026,11 +8096,11 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ &self.provider } } - impl FullRelayWithVerifyTestInstance<&P, N> { + impl HybridBTCStrategyForkedWbtcInstance<&P, N> { /// Clones the provider and returns a new instance with the cloned provider. #[inline] - pub fn with_cloned_provider(self) -> FullRelayWithVerifyTestInstance { - FullRelayWithVerifyTestInstance { + pub fn with_cloned_provider(self) -> HybridBTCStrategyForkedWbtcInstance { + HybridBTCStrategyForkedWbtcInstance { address: self.address, provider: ::core::clone::Clone::clone(&self.provider), _network: ::core::marker::PhantomData, @@ -8042,7 +8112,7 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ impl< P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - > FullRelayWithVerifyTestInstance { + > HybridBTCStrategyForkedWbtcInstance { /// 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 @@ -8057,6 +8127,10 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { self.call_builder(&IS_TESTCall) } + ///Creates a new call builder for the [`amountIn`] function. + pub fn amountIn(&self) -> alloy_contract::SolCallBuilder<&P, amountInCall, N> { + self.call_builder(&amountInCall) + } ///Creates a new call builder for the [`excludeArtifacts`] function. pub fn excludeArtifacts( &self, @@ -8085,63 +8159,24 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { self.call_builder(&failedCall) } - ///Creates a new call builder for the [`getBlockHeights`] function. - pub fn getBlockHeights( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getBlockHeightsCall, N> { - self.call_builder( - &getBlockHeightsCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getDigestLes`] function. - pub fn getDigestLes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getDigestLesCall, N> { - self.call_builder( - &getDigestLesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaderHexes`] function. - pub fn getHeaderHexes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeaderHexesCall, N> { - self.call_builder( - &getHeaderHexesCall { - chainName, - from, - to, - }, - ) + ///Creates a new call builder for the [`setUp`] function. + pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { + self.call_builder(&setUpCall) } - ///Creates a new call builder for the [`getHeaders`] function. - pub fn getHeaders( + ///Creates a new call builder for the [`simulateForkAndTransfer`] function. + pub fn simulateForkAndTransfer( &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeadersCall, N> { + forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + sender: alloy::sol_types::private::Address, + receiver: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { self.call_builder( - &getHeadersCall { - chainName, - from, - to, + &simulateForkAndTransferCall { + forkAtBlock, + sender, + receiver, + amount, }, ) } @@ -8181,13 +8216,23 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { self.call_builder(&targetSendersCall) } + ///Creates a new call builder for the [`testDepositToVault`] function. + pub fn testDepositToVault( + &self, + ) -> alloy_contract::SolCallBuilder<&P, testDepositToVaultCall, N> { + self.call_builder(&testDepositToVaultCall) + } + ///Creates a new call builder for the [`token`] function. + pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { + self.call_builder(&tokenCall) + } } /// Event filters. #[automatically_derived] impl< P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - > FullRelayWithVerifyTestInstance { + > HybridBTCStrategyForkedWbtcInstance { /// 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. @@ -8197,6 +8242,10 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ ) -> alloy_contract::Event<&P, E, N> { alloy_contract::Event::new_sol(&self.provider, &self.address) } + ///Creates a new event filter for the [`TokenOutput`] event. + pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { + self.event_filter::() + } ///Creates a new event filter for the [`log`] event. pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { self.event_filter::() diff --git a/crates/bindings/src/i_avalon_i_pool.rs b/crates/bindings/src/i_avalon_i_pool.rs new file mode 100644 index 000000000..ae56844c8 --- /dev/null +++ b/crates/bindings/src/i_avalon_i_pool.rs @@ -0,0 +1,808 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface IAvalonIPool { + function supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external; + function withdraw(address asset, uint256 amount, address to) external returns (uint256); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "supply", + "inputs": [ + { + "name": "asset", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "onBehalfOf", + "type": "address", + "internalType": "address" + }, + { + "name": "referralCode", + "type": "uint16", + "internalType": "uint16" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "withdraw", + "inputs": [ + { + "name": "asset", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "to", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "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 IAvalonIPool { + use super::*; + use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `supply(address,uint256,address,uint16)` and selector `0x617ba037`. +```solidity +function supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct supplyCall { + #[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 onBehalfOf: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub referralCode: u16, + } + ///Container type for the return parameters of the [`supply(address,uint256,address,uint16)`](supplyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct supplyReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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<16>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Address, + u16, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: supplyCall) -> Self { + (value.asset, value.amount, value.onBehalfOf, value.referralCode) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for supplyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + asset: tuple.0, + amount: tuple.1, + onBehalfOf: tuple.2, + referralCode: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: supplyReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for supplyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl supplyReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for supplyCall { + 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<16>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = supplyReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "supply(address,uint256,address,uint16)"; + const SELECTOR: [u8; 4] = [97u8, 123u8, 160u8, 55u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.asset, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ::tokenize( + &self.onBehalfOf, + ), + as alloy_sol_types::SolType>::tokenize(&self.referralCode), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + supplyReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `withdraw(address,uint256,address)` and selector `0x69328dec`. +```solidity +function withdraw(address asset, uint256 amount, address to) external returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct withdrawCall { + #[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 to: alloy::sol_types::private::Address, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`withdraw(address,uint256,address)`](withdrawCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct withdrawReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: withdrawCall) -> Self { + (value.asset, value.amount, value.to) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for withdrawCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + asset: tuple.0, + amount: tuple.1, + to: tuple.2, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: withdrawReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for withdrawReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[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::Address, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "withdraw(address,uint256,address)"; + const SELECTOR: [u8; 4] = [105u8, 50u8, 141u8, 236u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.asset, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ::tokenize( + &self.to, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: withdrawReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: withdrawReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`IAvalonIPool`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum IAvalonIPoolCalls { + #[allow(missing_docs)] + supply(supplyCall), + #[allow(missing_docs)] + withdraw(withdrawCall), + } + #[automatically_derived] + impl IAvalonIPoolCalls { + /// 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]] = &[ + [97u8, 123u8, 160u8, 55u8], + [105u8, 50u8, 141u8, 236u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for IAvalonIPoolCalls { + const NAME: &'static str = "IAvalonIPoolCalls"; + const MIN_DATA_LENGTH: usize = 96usize; + const COUNT: usize = 2usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::supply(_) => ::SELECTOR, + Self::withdraw(_) => ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn supply( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IAvalonIPoolCalls::supply) + } + supply + }, + { + fn withdraw( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IAvalonIPoolCalls::withdraw) + } + withdraw + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn supply( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAvalonIPoolCalls::supply) + } + supply + }, + { + fn withdraw( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IAvalonIPoolCalls::withdraw) + } + withdraw + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::supply(inner) => { + ::abi_encoded_size(inner) + } + Self::withdraw(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::supply(inner) => { + ::abi_encode_raw(inner, out) + } + Self::withdraw(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`IAvalonIPool`](self) contract instance. + +See the [wrapper's documentation](`IAvalonIPoolInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> IAvalonIPoolInstance { + IAvalonIPoolInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + IAvalonIPoolInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + IAvalonIPoolInstance::::deploy_builder(provider) + } + /**A [`IAvalonIPool`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`IAvalonIPool`](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 IAvalonIPoolInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for IAvalonIPoolInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("IAvalonIPoolInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IAvalonIPoolInstance { + /**Creates a new wrapper around an on-chain [`IAvalonIPool`](self) contract instance. + +See the [wrapper's documentation](`IAvalonIPoolInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 IAvalonIPoolInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> IAvalonIPoolInstance { + IAvalonIPoolInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IAvalonIPoolInstance { + /// 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( + &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 [`supply`] function. + pub fn supply( + &self, + asset: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + onBehalfOf: alloy::sol_types::private::Address, + referralCode: u16, + ) -> alloy_contract::SolCallBuilder<&P, supplyCall, N> { + self.call_builder( + &supplyCall { + asset, + amount, + onBehalfOf, + referralCode, + }, + ) + } + ///Creates a new call builder for the [`withdraw`] function. + pub fn withdraw( + &self, + asset: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + to: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, withdrawCall, N> { + self.call_builder(&withdrawCall { asset, amount, to }) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IAvalonIPoolInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/i_bedrock_vault.rs b/crates/bindings/src/i_bedrock_vault.rs new file mode 100644 index 000000000..693007172 --- /dev/null +++ b/crates/bindings/src/i_bedrock_vault.rs @@ -0,0 +1,924 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface IBedrockVault { + function mint(address _token, uint256 _amount) external; + function redeem(address _token, uint256 _amount) external; + function uniBTC() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "mint", + "inputs": [ + { + "name": "_token", + "type": "address", + "internalType": "address" + }, + { + "name": "_amount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "redeem", + "inputs": [ + { + "name": "_token", + "type": "address", + "internalType": "address" + }, + { + "name": "_amount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "uniBTC", + "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 IBedrockVault { + use super::*; + use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `mint(address,uint256)` and selector `0x40c10f19`. +```solidity +function mint(address _token, uint256 _amount) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct mintCall { + #[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 [`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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: mintCall) -> Self { + (value._token, value._amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for mintCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _token: tuple.0, + _amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: mintReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for mintReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl mintReturn { + fn _tokenize( + &self, + ) -> ::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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = mintReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "mint(address,uint256)"; + const SELECTOR: [u8; 4] = [64u8, 193u8, 15u8, 25u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._token, + ), + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `redeem(address,uint256)` and selector `0x1e9a6950`. +```solidity +function redeem(address _token, uint256 _amount) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct redeemCall { + #[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 [`redeem(address,uint256)`](redeemCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct redeemReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: redeemCall) -> Self { + (value._token, value._amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for redeemCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _token: tuple.0, + _amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: redeemReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for redeemReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl redeemReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for redeemCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = redeemReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "redeem(address,uint256)"; + const SELECTOR: [u8; 4] = [30u8, 154u8, 105u8, 80u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._token, + ), + as alloy_sol_types::SolType>::tokenize(&self._amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + redeemReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `uniBTC()` and selector `0x59f3d39b`. +```solidity +function uniBTC() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct uniBTCCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`uniBTC()`](uniBTCCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct uniBTCReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: uniBTCCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for uniBTCCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: uniBTCReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for uniBTCReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for uniBTCCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "uniBTC()"; + const SELECTOR: [u8; 4] = [89u8, 243u8, 211u8, 155u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: uniBTCReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: uniBTCReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`IBedrockVault`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum IBedrockVaultCalls { + #[allow(missing_docs)] + mint(mintCall), + #[allow(missing_docs)] + redeem(redeemCall), + #[allow(missing_docs)] + uniBTC(uniBTCCall), + } + #[automatically_derived] + impl IBedrockVaultCalls { + /// 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]] = &[ + [30u8, 154u8, 105u8, 80u8], + [64u8, 193u8, 15u8, 25u8], + [89u8, 243u8, 211u8, 155u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for IBedrockVaultCalls { + const NAME: &'static str = "IBedrockVaultCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 3usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::mint(_) => ::SELECTOR, + Self::redeem(_) => ::SELECTOR, + Self::uniBTC(_) => ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn redeem( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IBedrockVaultCalls::redeem) + } + redeem + }, + { + fn mint(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IBedrockVaultCalls::mint) + } + mint + }, + { + fn uniBTC( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IBedrockVaultCalls::uniBTC) + } + uniBTC + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn redeem( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IBedrockVaultCalls::redeem) + } + redeem + }, + { + fn mint(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IBedrockVaultCalls::mint) + } + mint + }, + { + fn uniBTC( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IBedrockVaultCalls::uniBTC) + } + uniBTC + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::mint(inner) => { + ::abi_encoded_size(inner) + } + Self::redeem(inner) => { + ::abi_encoded_size(inner) + } + Self::uniBTC(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::mint(inner) => { + ::abi_encode_raw(inner, out) + } + Self::redeem(inner) => { + ::abi_encode_raw(inner, out) + } + Self::uniBTC(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`IBedrockVault`](self) contract instance. + +See the [wrapper's documentation](`IBedrockVaultInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> IBedrockVaultInstance { + IBedrockVaultInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + IBedrockVaultInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + IBedrockVaultInstance::::deploy_builder(provider) + } + /**A [`IBedrockVault`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`IBedrockVault`](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 IBedrockVaultInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for IBedrockVaultInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("IBedrockVaultInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IBedrockVaultInstance { + /**Creates a new wrapper around an on-chain [`IBedrockVault`](self) contract instance. + +See the [wrapper's documentation](`IBedrockVaultInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 IBedrockVaultInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> IBedrockVaultInstance { + IBedrockVaultInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IBedrockVaultInstance { + /// 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( + &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 [`mint`] function. + pub fn mint( + &self, + _token: alloy::sol_types::private::Address, + _amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> { + self.call_builder(&mintCall { _token, _amount }) + } + ///Creates a new call builder for the [`redeem`] function. + pub fn redeem( + &self, + _token: alloy::sol_types::private::Address, + _amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, redeemCall, N> { + self.call_builder(&redeemCall { _token, _amount }) + } + ///Creates a new call builder for the [`uniBTC`] function. + pub fn uniBTC(&self) -> alloy_contract::SolCallBuilder<&P, uniBTCCall, N> { + self.call_builder(&uniBTCCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IBedrockVaultInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/ifullrelay.rs b/crates/bindings/src/i_full_relay.rs similarity index 100% rename from crates/bindings/src/ifullrelay.rs rename to crates/bindings/src/i_full_relay.rs diff --git a/crates/bindings/src/ifullrelaywithverify.rs b/crates/bindings/src/i_full_relay_with_verify.rs similarity index 100% rename from crates/bindings/src/ifullrelaywithverify.rs rename to crates/bindings/src/i_full_relay_with_verify.rs diff --git a/crates/bindings/src/i_ionic_token.rs b/crates/bindings/src/i_ionic_token.rs new file mode 100644 index 000000000..827cacfe4 --- /dev/null +++ b/crates/bindings/src/i_ionic_token.rs @@ -0,0 +1,719 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface IIonicToken { + function mint(uint256 mintAmount) external returns (uint256); + function redeem(uint256 redeemTokens) external returns (uint256); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "mint", + "inputs": [ + { + "name": "mintAmount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "redeem", + "inputs": [ + { + "name": "redeemTokens", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "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 IIonicToken { + use super::*; + use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `mint(uint256)` and selector `0xa0712d68`. +```solidity +function mint(uint256 mintAmount) external returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct mintCall { + #[allow(missing_docs)] + pub mintAmount: alloy::sol_types::private::primitives::aliases::U256, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`mint(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: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: mintCall) -> Self { + (value.mintAmount,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for mintCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { mintAmount: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: mintReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "mint(uint256)"; + const SELECTOR: [u8; 4] = [160u8, 113u8, 45u8, 104u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.mintAmount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: mintReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `redeem(uint256)` and selector `0xdb006a75`. +```solidity +function redeem(uint256 redeemTokens) external returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct redeemCall { + #[allow(missing_docs)] + pub redeemTokens: alloy::sol_types::private::primitives::aliases::U256, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`redeem(uint256)`](redeemCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct redeemReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: redeemCall) -> Self { + (value.redeemTokens,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for redeemCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { redeemTokens: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: redeemReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for redeemReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for redeemCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "redeem(uint256)"; + const SELECTOR: [u8; 4] = [219u8, 0u8, 106u8, 117u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.redeemTokens), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: redeemReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: redeemReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`IIonicToken`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum IIonicTokenCalls { + #[allow(missing_docs)] + mint(mintCall), + #[allow(missing_docs)] + redeem(redeemCall), + } + #[automatically_derived] + impl IIonicTokenCalls { + /// 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]] = &[ + [160u8, 113u8, 45u8, 104u8], + [219u8, 0u8, 106u8, 117u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for IIonicTokenCalls { + const NAME: &'static str = "IIonicTokenCalls"; + const MIN_DATA_LENGTH: usize = 32usize; + const COUNT: usize = 2usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::mint(_) => ::SELECTOR, + Self::redeem(_) => ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn mint(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IIonicTokenCalls::mint) + } + mint + }, + { + fn redeem(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IIonicTokenCalls::redeem) + } + redeem + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn mint(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IIonicTokenCalls::mint) + } + mint + }, + { + fn redeem(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IIonicTokenCalls::redeem) + } + redeem + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::mint(inner) => { + ::abi_encoded_size(inner) + } + Self::redeem(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::mint(inner) => { + ::abi_encode_raw(inner, out) + } + Self::redeem(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`IIonicToken`](self) contract instance. + +See the [wrapper's documentation](`IIonicTokenInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> IIonicTokenInstance { + IIonicTokenInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + IIonicTokenInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + IIonicTokenInstance::::deploy_builder(provider) + } + /**A [`IIonicToken`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`IIonicToken`](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 IIonicTokenInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for IIonicTokenInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("IIonicTokenInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IIonicTokenInstance { + /**Creates a new wrapper around an on-chain [`IIonicToken`](self) contract instance. + +See the [wrapper's documentation](`IIonicTokenInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 IIonicTokenInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> IIonicTokenInstance { + IIonicTokenInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IIonicTokenInstance { + /// 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( + &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 [`mint`] function. + pub fn mint( + &self, + mintAmount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> { + self.call_builder(&mintCall { mintAmount }) + } + ///Creates a new call builder for the [`redeem`] function. + pub fn redeem( + &self, + redeemTokens: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, redeemCall, N> { + self.call_builder(&redeemCall { redeemTokens }) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IIonicTokenInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/i_light_relay.rs b/crates/bindings/src/i_light_relay.rs new file mode 100644 index 000000000..81d0227a4 --- /dev/null +++ b/crates/bindings/src/i_light_relay.rs @@ -0,0 +1,2550 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface ILightRelay { + event AuthorizationRequirementChanged(bool newStatus); + event Genesis(uint256 blockHeight); + event ProofLengthChanged(uint256 newLength); + event Retarget(uint256 oldDifficulty, uint256 newDifficulty); + event SubmitterAuthorized(address submitter); + event SubmitterDeauthorized(address submitter); + + function getBlockDifficulty(uint256 blockNumber) external view returns (uint256); + function getCurrentEpochDifficulty() external view returns (uint256); + function getPrevEpochDifficulty() external view returns (uint256); + function getRelayRange() external view returns (uint256 relayGenesis, uint256 currentEpochEnd); + function retarget(bytes memory headers) external; + function validateChain(bytes memory headers) external view returns (uint256 startingHeaderTimestamp, uint256 headerCount); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "getBlockDifficulty", + "inputs": [ + { + "name": "blockNumber", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getCurrentEpochDifficulty", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getPrevEpochDifficulty", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getRelayRange", + "inputs": [], + "outputs": [ + { + "name": "relayGenesis", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "currentEpochEnd", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "retarget", + "inputs": [ + { + "name": "headers", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "validateChain", + "inputs": [ + { + "name": "headers", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [ + { + "name": "startingHeaderTimestamp", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "headerCount", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "AuthorizationRequirementChanged", + "inputs": [ + { + "name": "newStatus", + "type": "bool", + "indexed": false, + "internalType": "bool" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Genesis", + "inputs": [ + { + "name": "blockHeight", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "ProofLengthChanged", + "inputs": [ + { + "name": "newLength", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Retarget", + "inputs": [ + { + "name": "oldDifficulty", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "newDifficulty", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "SubmitterAuthorized", + "inputs": [ + { + "name": "submitter", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "SubmitterDeauthorized", + "inputs": [ + { + "name": "submitter", + "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 ILightRelay { + use super::*; + use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `AuthorizationRequirementChanged(bool)` and selector `0xd813b248d49c8bf08be2b6947126da6763df310beed7bea97756456c5727419a`. +```solidity +event AuthorizationRequirementChanged(bool newStatus); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct AuthorizationRequirementChanged { + #[allow(missing_docs)] + pub newStatus: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for AuthorizationRequirementChanged { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "AuthorizationRequirementChanged(bool)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 216u8, 19u8, 178u8, 72u8, 212u8, 156u8, 139u8, 240u8, 139u8, 226u8, + 182u8, 148u8, 113u8, 38u8, 218u8, 103u8, 99u8, 223u8, 49u8, 11u8, 238u8, + 215u8, 190u8, 169u8, 119u8, 86u8, 69u8, 108u8, 87u8, 39u8, 65u8, 154u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { newStatus: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.newStatus, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 AuthorizationRequirementChanged { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&AuthorizationRequirementChanged> + for alloy_sol_types::private::LogData { + #[inline] + fn from( + this: &AuthorizationRequirementChanged, + ) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `Genesis(uint256)` and selector `0x2381d16925551c2fb1a5edfcf4fce2f6d085e1f85f4b88340c09c9d191f9d4e9`. +```solidity +event Genesis(uint256 blockHeight); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct Genesis { + #[allow(missing_docs)] + pub blockHeight: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Genesis { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "Genesis(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 35u8, 129u8, 209u8, 105u8, 37u8, 85u8, 28u8, 47u8, 177u8, 165u8, 237u8, + 252u8, 244u8, 252u8, 226u8, 246u8, 208u8, 133u8, 225u8, 248u8, 95u8, + 75u8, 136u8, 52u8, 12u8, 9u8, 201u8, 209u8, 145u8, 249u8, 212u8, 233u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { blockHeight: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.blockHeight), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 Genesis { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&Genesis> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &Genesis) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `ProofLengthChanged(uint256)` and selector `0x3e9f904d8cf11753c79b67c8259c582056d4a7d8af120f81257a59eeb8824b96`. +```solidity +event ProofLengthChanged(uint256 newLength); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct ProofLengthChanged { + #[allow(missing_docs)] + pub newLength: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for ProofLengthChanged { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "ProofLengthChanged(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 62u8, 159u8, 144u8, 77u8, 140u8, 241u8, 23u8, 83u8, 199u8, 155u8, 103u8, + 200u8, 37u8, 156u8, 88u8, 32u8, 86u8, 212u8, 167u8, 216u8, 175u8, 18u8, + 15u8, 129u8, 37u8, 122u8, 89u8, 238u8, 184u8, 130u8, 75u8, 150u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { newLength: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.newLength), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 ProofLengthChanged { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&ProofLengthChanged> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &ProofLengthChanged) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `Retarget(uint256,uint256)` and selector `0xa282ee798b132f9dc11e06cd4d8e767e562be8709602ca14fea7ab3392acbdab`. +```solidity +event Retarget(uint256 oldDifficulty, uint256 newDifficulty); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct Retarget { + #[allow(missing_docs)] + pub oldDifficulty: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub newDifficulty: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Retarget { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "Retarget(uint256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 162u8, 130u8, 238u8, 121u8, 139u8, 19u8, 47u8, 157u8, 193u8, 30u8, 6u8, + 205u8, 77u8, 142u8, 118u8, 126u8, 86u8, 43u8, 232u8, 112u8, 150u8, 2u8, + 202u8, 20u8, 254u8, 167u8, 171u8, 51u8, 146u8, 172u8, 189u8, 171u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + oldDifficulty: data.0, + newDifficulty: data.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.oldDifficulty), + as alloy_sol_types::SolType>::tokenize(&self.newDifficulty), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 Retarget { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&Retarget> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &Retarget) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `SubmitterAuthorized(address)` and selector `0xd53649b492f738bb59d6825099b5955073efda0bf9e3a7ad20da22e110122e29`. +```solidity +event SubmitterAuthorized(address submitter); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct SubmitterAuthorized { + #[allow(missing_docs)] + pub submitter: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for SubmitterAuthorized { + type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "SubmitterAuthorized(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 213u8, 54u8, 73u8, 180u8, 146u8, 247u8, 56u8, 187u8, 89u8, 214u8, 130u8, + 80u8, 153u8, 181u8, 149u8, 80u8, 115u8, 239u8, 218u8, 11u8, 249u8, 227u8, + 167u8, 173u8, 32u8, 218u8, 34u8, 225u8, 16u8, 18u8, 46u8, 41u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { submitter: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.submitter, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 SubmitterAuthorized { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&SubmitterAuthorized> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &SubmitterAuthorized) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `SubmitterDeauthorized(address)` and selector `0x7498b96beeabea5ad3139f1a2861a03e480034254e36b10aae2e6e42ad7b4b68`. +```solidity +event SubmitterDeauthorized(address submitter); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct SubmitterDeauthorized { + #[allow(missing_docs)] + pub submitter: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for SubmitterDeauthorized { + type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "SubmitterDeauthorized(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 116u8, 152u8, 185u8, 107u8, 238u8, 171u8, 234u8, 90u8, 211u8, 19u8, + 159u8, 26u8, 40u8, 97u8, 160u8, 62u8, 72u8, 0u8, 52u8, 37u8, 78u8, 54u8, + 177u8, 10u8, 174u8, 46u8, 110u8, 66u8, 173u8, 123u8, 75u8, 104u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { submitter: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.submitter, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 SubmitterDeauthorized { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&SubmitterDeauthorized> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &SubmitterDeauthorized) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `getBlockDifficulty(uint256)` and selector `0x06a27422`. +```solidity +function getBlockDifficulty(uint256 blockNumber) external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getBlockDifficultyCall { + #[allow(missing_docs)] + pub blockNumber: alloy::sol_types::private::primitives::aliases::U256, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`getBlockDifficulty(uint256)`](getBlockDifficultyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getBlockDifficultyReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getBlockDifficultyCall) -> Self { + (value.blockNumber,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getBlockDifficultyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { blockNumber: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getBlockDifficultyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getBlockDifficultyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getBlockDifficultyCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getBlockDifficulty(uint256)"; + const SELECTOR: [u8; 4] = [6u8, 162u8, 116u8, 34u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.blockNumber), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: getBlockDifficultyReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: getBlockDifficultyReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `getCurrentEpochDifficulty()` and selector `0x113764be`. +```solidity +function getCurrentEpochDifficulty() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getCurrentEpochDifficultyCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`getCurrentEpochDifficulty()`](getCurrentEpochDifficultyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getCurrentEpochDifficultyReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getCurrentEpochDifficultyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getCurrentEpochDifficultyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getCurrentEpochDifficultyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getCurrentEpochDifficultyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getCurrentEpochDifficultyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getCurrentEpochDifficulty()"; + const SELECTOR: [u8; 4] = [17u8, 55u8, 100u8, 190u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: getCurrentEpochDifficultyReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: getCurrentEpochDifficultyReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `getPrevEpochDifficulty()` and selector `0x2b97be24`. +```solidity +function getPrevEpochDifficulty() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getPrevEpochDifficultyCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`getPrevEpochDifficulty()`](getPrevEpochDifficultyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getPrevEpochDifficultyReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getPrevEpochDifficultyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getPrevEpochDifficultyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getPrevEpochDifficultyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getPrevEpochDifficultyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getPrevEpochDifficultyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getPrevEpochDifficulty()"; + const SELECTOR: [u8; 4] = [43u8, 151u8, 190u8, 36u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: getPrevEpochDifficultyReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: getPrevEpochDifficultyReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `getRelayRange()` and selector `0x10b76ed8`. +```solidity +function getRelayRange() external view returns (uint256 relayGenesis, uint256 currentEpochEnd); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getRelayRangeCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`getRelayRange()`](getRelayRangeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getRelayRangeReturn { + #[allow(missing_docs)] + pub relayGenesis: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub currentEpochEnd: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: getRelayRangeCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for getRelayRangeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: getRelayRangeReturn) -> Self { + (value.relayGenesis, value.currentEpochEnd) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for getRelayRangeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + relayGenesis: tuple.0, + currentEpochEnd: tuple.1, + } + } + } + } + impl getRelayRangeReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.relayGenesis), + as alloy_sol_types::SolType>::tokenize(&self.currentEpochEnd), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getRelayRangeCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = getRelayRangeReturn; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getRelayRange()"; + const SELECTOR: [u8; 4] = [16u8, 183u8, 110u8, 216u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + getRelayRangeReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `retarget(bytes)` and selector `0x7ca5b1dd`. +```solidity +function retarget(bytes memory headers) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct retargetCall { + #[allow(missing_docs)] + pub headers: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`retarget(bytes)`](retargetCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct retargetReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: retargetCall) -> Self { + (value.headers,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for retargetCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { headers: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: retargetReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for retargetReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl retargetReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for retargetCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Bytes,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = retargetReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "retarget(bytes)"; + const SELECTOR: [u8; 4] = [124u8, 165u8, 177u8, 221u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.headers, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + retargetReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `validateChain(bytes)` and selector `0x189179a3`. +```solidity +function validateChain(bytes memory headers) external view returns (uint256 startingHeaderTimestamp, uint256 headerCount); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct validateChainCall { + #[allow(missing_docs)] + pub headers: alloy::sol_types::private::Bytes, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`validateChain(bytes)`](validateChainCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct validateChainReturn { + #[allow(missing_docs)] + pub startingHeaderTimestamp: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub headerCount: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: validateChainCall) -> Self { + (value.headers,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for validateChainCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { headers: tuple.0 } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: validateChainReturn) -> Self { + (value.startingHeaderTimestamp, value.headerCount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for validateChainReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + startingHeaderTimestamp: tuple.0, + headerCount: tuple.1, + } + } + } + } + impl validateChainReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize( + &self.startingHeaderTimestamp, + ), + as alloy_sol_types::SolType>::tokenize(&self.headerCount), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for validateChainCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Bytes,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = validateChainReturn; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "validateChain(bytes)"; + const SELECTOR: [u8; 4] = [24u8, 145u8, 121u8, 163u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.headers, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + validateChainReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + ///Container for all the [`ILightRelay`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum ILightRelayCalls { + #[allow(missing_docs)] + getBlockDifficulty(getBlockDifficultyCall), + #[allow(missing_docs)] + getCurrentEpochDifficulty(getCurrentEpochDifficultyCall), + #[allow(missing_docs)] + getPrevEpochDifficulty(getPrevEpochDifficultyCall), + #[allow(missing_docs)] + getRelayRange(getRelayRangeCall), + #[allow(missing_docs)] + retarget(retargetCall), + #[allow(missing_docs)] + validateChain(validateChainCall), + } + #[automatically_derived] + impl ILightRelayCalls { + /// 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, 162u8, 116u8, 34u8], + [16u8, 183u8, 110u8, 216u8], + [17u8, 55u8, 100u8, 190u8], + [24u8, 145u8, 121u8, 163u8], + [43u8, 151u8, 190u8, 36u8], + [124u8, 165u8, 177u8, 221u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for ILightRelayCalls { + const NAME: &'static str = "ILightRelayCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 6usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::getBlockDifficulty(_) => { + ::SELECTOR + } + Self::getCurrentEpochDifficulty(_) => { + ::SELECTOR + } + Self::getPrevEpochDifficulty(_) => { + ::SELECTOR + } + Self::getRelayRange(_) => { + ::SELECTOR + } + Self::retarget(_) => ::SELECTOR, + Self::validateChain(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn getBlockDifficulty( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ILightRelayCalls::getBlockDifficulty) + } + getBlockDifficulty + }, + { + fn getRelayRange( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ILightRelayCalls::getRelayRange) + } + getRelayRange + }, + { + fn getCurrentEpochDifficulty( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ILightRelayCalls::getCurrentEpochDifficulty) + } + getCurrentEpochDifficulty + }, + { + fn validateChain( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ILightRelayCalls::validateChain) + } + validateChain + }, + { + fn getPrevEpochDifficulty( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ILightRelayCalls::getPrevEpochDifficulty) + } + getPrevEpochDifficulty + }, + { + fn retarget( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ILightRelayCalls::retarget) + } + retarget + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn getBlockDifficulty( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ILightRelayCalls::getBlockDifficulty) + } + getBlockDifficulty + }, + { + fn getRelayRange( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ILightRelayCalls::getRelayRange) + } + getRelayRange + }, + { + fn getCurrentEpochDifficulty( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ILightRelayCalls::getCurrentEpochDifficulty) + } + getCurrentEpochDifficulty + }, + { + fn validateChain( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ILightRelayCalls::validateChain) + } + validateChain + }, + { + fn getPrevEpochDifficulty( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ILightRelayCalls::getPrevEpochDifficulty) + } + getPrevEpochDifficulty + }, + { + fn retarget( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ILightRelayCalls::retarget) + } + retarget + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::getBlockDifficulty(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getCurrentEpochDifficulty(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getPrevEpochDifficulty(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getRelayRange(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::retarget(inner) => { + ::abi_encoded_size(inner) + } + Self::validateChain(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::getBlockDifficulty(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getCurrentEpochDifficulty(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getPrevEpochDifficulty(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getRelayRange(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::retarget(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::validateChain(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`ILightRelay`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum ILightRelayEvents { + #[allow(missing_docs)] + AuthorizationRequirementChanged(AuthorizationRequirementChanged), + #[allow(missing_docs)] + Genesis(Genesis), + #[allow(missing_docs)] + ProofLengthChanged(ProofLengthChanged), + #[allow(missing_docs)] + Retarget(Retarget), + #[allow(missing_docs)] + SubmitterAuthorized(SubmitterAuthorized), + #[allow(missing_docs)] + SubmitterDeauthorized(SubmitterDeauthorized), + } + #[automatically_derived] + impl ILightRelayEvents { + /// 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]] = &[ + [ + 35u8, 129u8, 209u8, 105u8, 37u8, 85u8, 28u8, 47u8, 177u8, 165u8, 237u8, + 252u8, 244u8, 252u8, 226u8, 246u8, 208u8, 133u8, 225u8, 248u8, 95u8, + 75u8, 136u8, 52u8, 12u8, 9u8, 201u8, 209u8, 145u8, 249u8, 212u8, 233u8, + ], + [ + 62u8, 159u8, 144u8, 77u8, 140u8, 241u8, 23u8, 83u8, 199u8, 155u8, 103u8, + 200u8, 37u8, 156u8, 88u8, 32u8, 86u8, 212u8, 167u8, 216u8, 175u8, 18u8, + 15u8, 129u8, 37u8, 122u8, 89u8, 238u8, 184u8, 130u8, 75u8, 150u8, + ], + [ + 116u8, 152u8, 185u8, 107u8, 238u8, 171u8, 234u8, 90u8, 211u8, 19u8, + 159u8, 26u8, 40u8, 97u8, 160u8, 62u8, 72u8, 0u8, 52u8, 37u8, 78u8, 54u8, + 177u8, 10u8, 174u8, 46u8, 110u8, 66u8, 173u8, 123u8, 75u8, 104u8, + ], + [ + 162u8, 130u8, 238u8, 121u8, 139u8, 19u8, 47u8, 157u8, 193u8, 30u8, 6u8, + 205u8, 77u8, 142u8, 118u8, 126u8, 86u8, 43u8, 232u8, 112u8, 150u8, 2u8, + 202u8, 20u8, 254u8, 167u8, 171u8, 51u8, 146u8, 172u8, 189u8, 171u8, + ], + [ + 213u8, 54u8, 73u8, 180u8, 146u8, 247u8, 56u8, 187u8, 89u8, 214u8, 130u8, + 80u8, 153u8, 181u8, 149u8, 80u8, 115u8, 239u8, 218u8, 11u8, 249u8, 227u8, + 167u8, 173u8, 32u8, 218u8, 34u8, 225u8, 16u8, 18u8, 46u8, 41u8, + ], + [ + 216u8, 19u8, 178u8, 72u8, 212u8, 156u8, 139u8, 240u8, 139u8, 226u8, + 182u8, 148u8, 113u8, 38u8, 218u8, 103u8, 99u8, 223u8, 49u8, 11u8, 238u8, + 215u8, 190u8, 169u8, 119u8, 86u8, 69u8, 108u8, 87u8, 39u8, 65u8, 154u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for ILightRelayEvents { + const NAME: &'static str = "ILightRelayEvents"; + const COUNT: usize = 6usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::AuthorizationRequirementChanged) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Genesis) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::ProofLengthChanged) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Retarget) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::SubmitterAuthorized) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::SubmitterDeauthorized) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 ILightRelayEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::AuthorizationRequirementChanged(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::Genesis(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::ProofLengthChanged(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::Retarget(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::SubmitterAuthorized(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::SubmitterDeauthorized(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::AuthorizationRequirementChanged(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::Genesis(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::ProofLengthChanged(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::Retarget(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::SubmitterAuthorized(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::SubmitterDeauthorized(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`ILightRelay`](self) contract instance. + +See the [wrapper's documentation](`ILightRelayInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> ILightRelayInstance { + ILightRelayInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + ILightRelayInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + ILightRelayInstance::::deploy_builder(provider) + } + /**A [`ILightRelay`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`ILightRelay`](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 ILightRelayInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for ILightRelayInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("ILightRelayInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ILightRelayInstance { + /**Creates a new wrapper around an on-chain [`ILightRelay`](self) contract instance. + +See the [wrapper's documentation](`ILightRelayInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 ILightRelayInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> ILightRelayInstance { + ILightRelayInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ILightRelayInstance { + /// 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( + &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 [`getBlockDifficulty`] function. + pub fn getBlockDifficulty( + &self, + blockNumber: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, getBlockDifficultyCall, N> { + self.call_builder( + &getBlockDifficultyCall { + blockNumber, + }, + ) + } + ///Creates a new call builder for the [`getCurrentEpochDifficulty`] function. + pub fn getCurrentEpochDifficulty( + &self, + ) -> alloy_contract::SolCallBuilder<&P, getCurrentEpochDifficultyCall, N> { + self.call_builder(&getCurrentEpochDifficultyCall) + } + ///Creates a new call builder for the [`getPrevEpochDifficulty`] function. + pub fn getPrevEpochDifficulty( + &self, + ) -> alloy_contract::SolCallBuilder<&P, getPrevEpochDifficultyCall, N> { + self.call_builder(&getPrevEpochDifficultyCall) + } + ///Creates a new call builder for the [`getRelayRange`] function. + pub fn getRelayRange( + &self, + ) -> alloy_contract::SolCallBuilder<&P, getRelayRangeCall, N> { + self.call_builder(&getRelayRangeCall) + } + ///Creates a new call builder for the [`retarget`] function. + pub fn retarget( + &self, + headers: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, retargetCall, N> { + self.call_builder(&retargetCall { headers }) + } + ///Creates a new call builder for the [`validateChain`] function. + pub fn validateChain( + &self, + headers: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, validateChainCall, N> { + self.call_builder(&validateChainCall { headers }) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ILightRelayInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`AuthorizationRequirementChanged`] event. + pub fn AuthorizationRequirementChanged_filter( + &self, + ) -> alloy_contract::Event<&P, AuthorizationRequirementChanged, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`Genesis`] event. + pub fn Genesis_filter(&self) -> alloy_contract::Event<&P, Genesis, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`ProofLengthChanged`] event. + pub fn ProofLengthChanged_filter( + &self, + ) -> alloy_contract::Event<&P, ProofLengthChanged, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`Retarget`] event. + pub fn Retarget_filter(&self) -> alloy_contract::Event<&P, Retarget, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`SubmitterAuthorized`] event. + pub fn SubmitterAuthorized_filter( + &self, + ) -> alloy_contract::Event<&P, SubmitterAuthorized, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`SubmitterDeauthorized`] event. + pub fn SubmitterDeauthorized_filter( + &self, + ) -> alloy_contract::Event<&P, SubmitterDeauthorized, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/i_pell_strategy.rs b/crates/bindings/src/i_pell_strategy.rs new file mode 100644 index 000000000..206823571 --- /dev/null +++ b/crates/bindings/src/i_pell_strategy.rs @@ -0,0 +1,218 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface IPellStrategy {} +``` + +...which was generated by the following JSON ABI: +```json +[] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod IPellStrategy { + use super::*; + use alloy::sol_types as 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"", + ); + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`IPellStrategy`](self) contract instance. + +See the [wrapper's documentation](`IPellStrategyInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> IPellStrategyInstance { + IPellStrategyInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + IPellStrategyInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + IPellStrategyInstance::::deploy_builder(provider) + } + /**A [`IPellStrategy`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`IPellStrategy`](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 IPellStrategyInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for IPellStrategyInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("IPellStrategyInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPellStrategyInstance { + /**Creates a new wrapper around an on-chain [`IPellStrategy`](self) contract instance. + +See the [wrapper's documentation](`IPellStrategyInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 IPellStrategyInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> IPellStrategyInstance { + IPellStrategyInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPellStrategyInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPellStrategyInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/i_pell_strategy_manager.rs b/crates/bindings/src/i_pell_strategy_manager.rs new file mode 100644 index 000000000..95cf9a1e6 --- /dev/null +++ b/crates/bindings/src/i_pell_strategy_manager.rs @@ -0,0 +1,841 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface IPellStrategyManager { + function depositIntoStrategyWithStaker(address staker, address strategy, address token, uint256 amount) external returns (uint256 shares); + function stakerStrategyShares(address staker, address strategy) external view returns (uint256); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "depositIntoStrategyWithStaker", + "inputs": [ + { + "name": "staker", + "type": "address", + "internalType": "address" + }, + { + "name": "strategy", + "type": "address", + "internalType": "contract IPellStrategy" + }, + { + "name": "token", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "shares", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "stakerStrategyShares", + "inputs": [ + { + "name": "staker", + "type": "address", + "internalType": "address" + }, + { + "name": "strategy", + "type": "address", + "internalType": "contract IPellStrategy" + } + ], + "outputs": [ + { + "name": "", + "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 IPellStrategyManager { + use super::*; + use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `depositIntoStrategyWithStaker(address,address,address,uint256)` and selector `0xe46842b7`. +```solidity +function depositIntoStrategyWithStaker(address staker, address strategy, address token, uint256 amount) external returns (uint256 shares); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct depositIntoStrategyWithStakerCall { + #[allow(missing_docs)] + pub staker: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub strategy: 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, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`depositIntoStrategyWithStaker(address,address,address,uint256)`](depositIntoStrategyWithStakerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct depositIntoStrategyWithStakerReturn { + #[allow(missing_docs)] + pub shares: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: depositIntoStrategyWithStakerCall) -> Self { + (value.staker, value.strategy, value.token, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for depositIntoStrategyWithStakerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + staker: tuple.0, + strategy: tuple.1, + token: tuple.2, + amount: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: depositIntoStrategyWithStakerReturn) -> Self { + (value.shares,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for depositIntoStrategyWithStakerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { shares: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for depositIntoStrategyWithStakerCall { + 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "depositIntoStrategyWithStaker(address,address,address,uint256)"; + const SELECTOR: [u8; 4] = [228u8, 104u8, 66u8, 183u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.staker, + ), + ::tokenize( + &self.strategy, + ), + ::tokenize( + &self.token, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: depositIntoStrategyWithStakerReturn = r.into(); + r.shares + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: depositIntoStrategyWithStakerReturn = r.into(); + r.shares + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `stakerStrategyShares(address,address)` and selector `0x7a7e0d92`. +```solidity +function stakerStrategyShares(address staker, address strategy) external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct stakerStrategySharesCall { + #[allow(missing_docs)] + pub staker: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub strategy: alloy::sol_types::private::Address, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`stakerStrategyShares(address,address)`](stakerStrategySharesCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct stakerStrategySharesReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: stakerStrategySharesCall) -> Self { + (value.staker, value.strategy) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for stakerStrategySharesCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + staker: tuple.0, + strategy: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: stakerStrategySharesReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for stakerStrategySharesReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for stakerStrategySharesCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "stakerStrategyShares(address,address)"; + const SELECTOR: [u8; 4] = [122u8, 126u8, 13u8, 146u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.staker, + ), + ::tokenize( + &self.strategy, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: stakerStrategySharesReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: stakerStrategySharesReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`IPellStrategyManager`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum IPellStrategyManagerCalls { + #[allow(missing_docs)] + depositIntoStrategyWithStaker(depositIntoStrategyWithStakerCall), + #[allow(missing_docs)] + stakerStrategyShares(stakerStrategySharesCall), + } + #[automatically_derived] + impl IPellStrategyManagerCalls { + /// 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]] = &[ + [122u8, 126u8, 13u8, 146u8], + [228u8, 104u8, 66u8, 183u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for IPellStrategyManagerCalls { + const NAME: &'static str = "IPellStrategyManagerCalls"; + const MIN_DATA_LENGTH: usize = 64usize; + const COUNT: usize = 2usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::depositIntoStrategyWithStaker(_) => { + ::SELECTOR + } + Self::stakerStrategyShares(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn stakerStrategyShares( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IPellStrategyManagerCalls::stakerStrategyShares) + } + stakerStrategyShares + }, + { + fn depositIntoStrategyWithStaker( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + IPellStrategyManagerCalls::depositIntoStrategyWithStaker, + ) + } + depositIntoStrategyWithStaker + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn stakerStrategyShares( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IPellStrategyManagerCalls::stakerStrategyShares) + } + stakerStrategyShares + }, + { + fn depositIntoStrategyWithStaker( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + IPellStrategyManagerCalls::depositIntoStrategyWithStaker, + ) + } + depositIntoStrategyWithStaker + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::depositIntoStrategyWithStaker(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::stakerStrategyShares(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::depositIntoStrategyWithStaker(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::stakerStrategyShares(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`IPellStrategyManager`](self) contract instance. + +See the [wrapper's documentation](`IPellStrategyManagerInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> IPellStrategyManagerInstance { + IPellStrategyManagerInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + IPellStrategyManagerInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + IPellStrategyManagerInstance::::deploy_builder(provider) + } + /**A [`IPellStrategyManager`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`IPellStrategyManager`](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 IPellStrategyManagerInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for IPellStrategyManagerInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("IPellStrategyManagerInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPellStrategyManagerInstance { + /**Creates a new wrapper around an on-chain [`IPellStrategyManager`](self) contract instance. + +See the [wrapper's documentation](`IPellStrategyManagerInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 IPellStrategyManagerInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> IPellStrategyManagerInstance { + IPellStrategyManagerInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPellStrategyManagerInstance { + /// 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( + &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 [`depositIntoStrategyWithStaker`] function. + pub fn depositIntoStrategyWithStaker( + &self, + staker: alloy::sol_types::private::Address, + strategy: alloy::sol_types::private::Address, + token: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, depositIntoStrategyWithStakerCall, N> { + self.call_builder( + &depositIntoStrategyWithStakerCall { + staker, + strategy, + token, + amount, + }, + ) + } + ///Creates a new call builder for the [`stakerStrategyShares`] function. + pub fn stakerStrategyShares( + &self, + staker: alloy::sol_types::private::Address, + strategy: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, stakerStrategySharesCall, N> { + self.call_builder( + &stakerStrategySharesCall { + staker, + strategy, + }, + ) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPellStrategyManagerInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/i_pool.rs b/crates/bindings/src/i_pool.rs new file mode 100644 index 000000000..2ce95c4c7 --- /dev/null +++ b/crates/bindings/src/i_pool.rs @@ -0,0 +1,740 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface IPool { + function enterMarkets(address[] memory cTokens) external returns (uint256[] memory); + function exitMarket(address cTokenAddress) external returns (uint256); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "enterMarkets", + "inputs": [ + { + "name": "cTokens", + "type": "address[]", + "internalType": "address[]" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256[]", + "internalType": "uint256[]" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "exitMarket", + "inputs": [ + { + "name": "cTokenAddress", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "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 IPool { + use super::*; + use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `enterMarkets(address[])` and selector `0xc2998238`. +```solidity +function enterMarkets(address[] memory cTokens) external returns (uint256[] memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct enterMarketsCall { + #[allow(missing_docs)] + pub cTokens: alloy::sol_types::private::Vec, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`enterMarkets(address[])`](enterMarketsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct enterMarketsReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: enterMarketsCall) -> Self { + (value.cTokens,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for enterMarketsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { cTokens: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array>, + ); + #[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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: enterMarketsReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for enterMarketsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for enterMarketsCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::primitives::aliases::U256, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array>, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "enterMarkets(address[])"; + const SELECTOR: [u8; 4] = [194u8, 153u8, 130u8, 56u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.cTokens), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + , + > as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: enterMarketsReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: enterMarketsReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `exitMarket(address)` and selector `0xede4edd0`. +```solidity +function exitMarket(address cTokenAddress) external returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct exitMarketCall { + #[allow(missing_docs)] + pub cTokenAddress: alloy::sol_types::private::Address, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`exitMarket(address)`](exitMarketCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct exitMarketReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: exitMarketCall) -> Self { + (value.cTokenAddress,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for exitMarketCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { cTokenAddress: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: exitMarketReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for exitMarketReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for exitMarketCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "exitMarket(address)"; + const SELECTOR: [u8; 4] = [237u8, 228u8, 237u8, 208u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.cTokenAddress, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: exitMarketReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: exitMarketReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`IPool`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum IPoolCalls { + #[allow(missing_docs)] + enterMarkets(enterMarketsCall), + #[allow(missing_docs)] + exitMarket(exitMarketCall), + } + #[automatically_derived] + impl IPoolCalls { + /// 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]] = &[ + [194u8, 153u8, 130u8, 56u8], + [237u8, 228u8, 237u8, 208u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for IPoolCalls { + const NAME: &'static str = "IPoolCalls"; + const MIN_DATA_LENGTH: usize = 32usize; + const COUNT: usize = 2usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::enterMarkets(_) => { + ::SELECTOR + } + Self::exitMarket(_) => { + ::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 { + static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result] = &[ + { + fn enterMarkets(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IPoolCalls::enterMarkets) + } + enterMarkets + }, + { + fn exitMarket(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IPoolCalls::exitMarket) + } + exitMarket + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn enterMarkets(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IPoolCalls::enterMarkets) + } + enterMarkets + }, + { + fn exitMarket(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IPoolCalls::exitMarket) + } + exitMarket + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::enterMarkets(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::exitMarket(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::enterMarkets(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::exitMarket(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`IPool`](self) contract instance. + +See the [wrapper's documentation](`IPoolInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >(address: alloy_sol_types::private::Address, provider: P) -> IPoolInstance { + IPoolInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + IPoolInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + IPoolInstance::::deploy_builder(provider) + } + /**A [`IPool`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`IPool`](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 IPoolInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for IPoolInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("IPoolInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPoolInstance { + /**Creates a new wrapper around an on-chain [`IPool`](self) contract instance. + +See the [wrapper's documentation](`IPoolInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 IPoolInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> IPoolInstance { + IPoolInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPoolInstance { + /// 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( + &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 [`enterMarkets`] function. + pub fn enterMarkets( + &self, + cTokens: alloy::sol_types::private::Vec, + ) -> alloy_contract::SolCallBuilder<&P, enterMarketsCall, N> { + self.call_builder(&enterMarketsCall { cTokens }) + } + ///Creates a new call builder for the [`exitMarket`] function. + pub fn exitMarket( + &self, + cTokenAddress: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, exitMarketCall, N> { + self.call_builder(&exitMarketCall { cTokenAddress }) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPoolInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/i_se_bep20.rs b/crates/bindings/src/i_se_bep20.rs new file mode 100644 index 000000000..b8e5ebe7a --- /dev/null +++ b/crates/bindings/src/i_se_bep20.rs @@ -0,0 +1,1185 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface ISeBep20 { + function balanceOfUnderlying(address owner) external returns (uint256); + function mint(uint256 mintAmount) external returns (uint256); + function mintBehalf(address receiver, uint256 mintAmount) external returns (uint256); + function redeem(uint256 redeemTokens) external returns (uint256); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "balanceOfUnderlying", + "inputs": [ + { + "name": "owner", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "mint", + "inputs": [ + { + "name": "mintAmount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "mintBehalf", + "inputs": [ + { + "name": "receiver", + "type": "address", + "internalType": "address" + }, + { + "name": "mintAmount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "redeem", + "inputs": [ + { + "name": "redeemTokens", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "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 ISeBep20 { + use super::*; + use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `balanceOfUnderlying(address)` and selector `0x3af9e669`. +```solidity +function balanceOfUnderlying(address owner) external returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct balanceOfUnderlyingCall { + #[allow(missing_docs)] + pub owner: alloy::sol_types::private::Address, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`balanceOfUnderlying(address)`](balanceOfUnderlyingCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct balanceOfUnderlyingReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: balanceOfUnderlyingCall) -> Self { + (value.owner,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for balanceOfUnderlyingCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { owner: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: balanceOfUnderlyingReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for balanceOfUnderlyingReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for balanceOfUnderlyingCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "balanceOfUnderlying(address)"; + const SELECTOR: [u8; 4] = [58u8, 249u8, 230u8, 105u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.owner, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: balanceOfUnderlyingReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: balanceOfUnderlyingReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `mint(uint256)` and selector `0xa0712d68`. +```solidity +function mint(uint256 mintAmount) external returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct mintCall { + #[allow(missing_docs)] + pub mintAmount: alloy::sol_types::private::primitives::aliases::U256, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`mint(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: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: mintCall) -> Self { + (value.mintAmount,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for mintCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { mintAmount: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: mintReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "mint(uint256)"; + const SELECTOR: [u8; 4] = [160u8, 113u8, 45u8, 104u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.mintAmount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: mintReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `mintBehalf(address,uint256)` and selector `0x23323e03`. +```solidity +function mintBehalf(address receiver, uint256 mintAmount) external returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct mintBehalfCall { + #[allow(missing_docs)] + pub receiver: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub mintAmount: alloy::sol_types::private::primitives::aliases::U256, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`mintBehalf(address,uint256)`](mintBehalfCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct mintBehalfReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: mintBehalfCall) -> Self { + (value.receiver, value.mintAmount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for mintBehalfCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + receiver: tuple.0, + mintAmount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: mintBehalfReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for mintBehalfReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for mintBehalfCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "mintBehalf(address,uint256)"; + const SELECTOR: [u8; 4] = [35u8, 50u8, 62u8, 3u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.receiver, + ), + as alloy_sol_types::SolType>::tokenize(&self.mintAmount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: mintBehalfReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: mintBehalfReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `redeem(uint256)` and selector `0xdb006a75`. +```solidity +function redeem(uint256 redeemTokens) external returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct redeemCall { + #[allow(missing_docs)] + pub redeemTokens: alloy::sol_types::private::primitives::aliases::U256, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`redeem(uint256)`](redeemCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct redeemReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: redeemCall) -> Self { + (value.redeemTokens,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for redeemCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { redeemTokens: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: redeemReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for redeemReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for redeemCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "redeem(uint256)"; + const SELECTOR: [u8; 4] = [219u8, 0u8, 106u8, 117u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.redeemTokens), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: redeemReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: redeemReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`ISeBep20`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum ISeBep20Calls { + #[allow(missing_docs)] + balanceOfUnderlying(balanceOfUnderlyingCall), + #[allow(missing_docs)] + mint(mintCall), + #[allow(missing_docs)] + mintBehalf(mintBehalfCall), + #[allow(missing_docs)] + redeem(redeemCall), + } + #[automatically_derived] + impl ISeBep20Calls { + /// 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]] = &[ + [35u8, 50u8, 62u8, 3u8], + [58u8, 249u8, 230u8, 105u8], + [160u8, 113u8, 45u8, 104u8], + [219u8, 0u8, 106u8, 117u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for ISeBep20Calls { + const NAME: &'static str = "ISeBep20Calls"; + const MIN_DATA_LENGTH: usize = 32usize; + const COUNT: usize = 4usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::balanceOfUnderlying(_) => { + ::SELECTOR + } + Self::mint(_) => ::SELECTOR, + Self::mintBehalf(_) => { + ::SELECTOR + } + Self::redeem(_) => ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn mintBehalf( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ISeBep20Calls::mintBehalf) + } + mintBehalf + }, + { + fn balanceOfUnderlying( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ISeBep20Calls::balanceOfUnderlying) + } + balanceOfUnderlying + }, + { + fn mint(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ISeBep20Calls::mint) + } + mint + }, + { + fn redeem(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ISeBep20Calls::redeem) + } + redeem + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn mintBehalf( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ISeBep20Calls::mintBehalf) + } + mintBehalf + }, + { + fn balanceOfUnderlying( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ISeBep20Calls::balanceOfUnderlying) + } + balanceOfUnderlying + }, + { + fn mint(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ISeBep20Calls::mint) + } + mint + }, + { + fn redeem(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ISeBep20Calls::redeem) + } + redeem + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::balanceOfUnderlying(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::mint(inner) => { + ::abi_encoded_size(inner) + } + Self::mintBehalf(inner) => { + ::abi_encoded_size(inner) + } + Self::redeem(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::balanceOfUnderlying(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::mint(inner) => { + ::abi_encode_raw(inner, out) + } + Self::mintBehalf(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::redeem(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`ISeBep20`](self) contract instance. + +See the [wrapper's documentation](`ISeBep20Instance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> ISeBep20Instance { + ISeBep20Instance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + ISeBep20Instance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + ISeBep20Instance::::deploy_builder(provider) + } + /**A [`ISeBep20`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`ISeBep20`](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 ISeBep20Instance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for ISeBep20Instance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("ISeBep20Instance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ISeBep20Instance { + /**Creates a new wrapper around an on-chain [`ISeBep20`](self) contract instance. + +See the [wrapper's documentation](`ISeBep20Instance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 ISeBep20Instance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> ISeBep20Instance { + ISeBep20Instance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ISeBep20Instance { + /// 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( + &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 [`balanceOfUnderlying`] function. + pub fn balanceOfUnderlying( + &self, + owner: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, balanceOfUnderlyingCall, N> { + self.call_builder(&balanceOfUnderlyingCall { owner }) + } + ///Creates a new call builder for the [`mint`] function. + pub fn mint( + &self, + mintAmount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> { + self.call_builder(&mintCall { mintAmount }) + } + ///Creates a new call builder for the [`mintBehalf`] function. + pub fn mintBehalf( + &self, + receiver: alloy::sol_types::private::Address, + mintAmount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, mintBehalfCall, N> { + self.call_builder( + &mintBehalfCall { + receiver, + mintAmount, + }, + ) + } + ///Creates a new call builder for the [`redeem`] function. + pub fn redeem( + &self, + redeemTokens: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, redeemCall, N> { + self.call_builder(&redeemCall { redeemTokens }) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ISeBep20Instance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/i_solv_btc_router.rs b/crates/bindings/src/i_solv_btc_router.rs new file mode 100644 index 000000000..8c233bace --- /dev/null +++ b/crates/bindings/src/i_solv_btc_router.rs @@ -0,0 +1,553 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface ISolvBTCRouter { + function createSubscription(bytes32 poolId, uint256 currencyAmount) external returns (uint256 shareValue); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "createSubscription", + "inputs": [ + { + "name": "poolId", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "currencyAmount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "shareValue", + "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 ISolvBTCRouter { + use super::*; + use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `createSubscription(bytes32,uint256)` and selector `0x6d724ead`. +```solidity +function createSubscription(bytes32 poolId, uint256 currencyAmount) external returns (uint256 shareValue); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct createSubscriptionCall { + #[allow(missing_docs)] + pub poolId: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub currencyAmount: alloy::sol_types::private::primitives::aliases::U256, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`createSubscription(bytes32,uint256)`](createSubscriptionCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct createSubscriptionReturn { + #[allow(missing_docs)] + pub shareValue: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: createSubscriptionCall) -> Self { + (value.poolId, value.currencyAmount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for createSubscriptionCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + poolId: tuple.0, + currencyAmount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: createSubscriptionReturn) -> Self { + (value.shareValue,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for createSubscriptionReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { shareValue: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for createSubscriptionCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "createSubscription(bytes32,uint256)"; + const SELECTOR: [u8; 4] = [109u8, 114u8, 78u8, 173u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.poolId), + as alloy_sol_types::SolType>::tokenize(&self.currencyAmount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: createSubscriptionReturn = r.into(); + r.shareValue + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: createSubscriptionReturn = r.into(); + r.shareValue + }) + } + } + }; + ///Container for all the [`ISolvBTCRouter`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum ISolvBTCRouterCalls { + #[allow(missing_docs)] + createSubscription(createSubscriptionCall), + } + #[automatically_derived] + impl ISolvBTCRouterCalls { + /// 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]] = &[[109u8, 114u8, 78u8, 173u8]]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for ISolvBTCRouterCalls { + const NAME: &'static str = "ISolvBTCRouterCalls"; + const MIN_DATA_LENGTH: usize = 64usize; + const COUNT: usize = 1usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::createSubscription(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn createSubscription( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ISolvBTCRouterCalls::createSubscription) + } + createSubscription + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn createSubscription( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ISolvBTCRouterCalls::createSubscription) + } + createSubscription + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::createSubscription(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::createSubscription(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`ISolvBTCRouter`](self) contract instance. + +See the [wrapper's documentation](`ISolvBTCRouterInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> ISolvBTCRouterInstance { + ISolvBTCRouterInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + ISolvBTCRouterInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + ISolvBTCRouterInstance::::deploy_builder(provider) + } + /**A [`ISolvBTCRouter`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`ISolvBTCRouter`](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 ISolvBTCRouterInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for ISolvBTCRouterInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("ISolvBTCRouterInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ISolvBTCRouterInstance { + /**Creates a new wrapper around an on-chain [`ISolvBTCRouter`](self) contract instance. + +See the [wrapper's documentation](`ISolvBTCRouterInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 ISolvBTCRouterInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> ISolvBTCRouterInstance { + ISolvBTCRouterInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ISolvBTCRouterInstance { + /// 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( + &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 [`createSubscription`] function. + pub fn createSubscription( + &self, + poolId: alloy::sol_types::private::FixedBytes<32>, + currencyAmount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, createSubscriptionCall, N> { + self.call_builder( + &createSubscriptionCall { + poolId, + currencyAmount, + }, + ) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ISolvBTCRouterInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/i_strategy.rs b/crates/bindings/src/i_strategy.rs new file mode 100644 index 000000000..dbffd2034 --- /dev/null +++ b/crates/bindings/src/i_strategy.rs @@ -0,0 +1,782 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface IStrategy { + event TokenOutput(address tokenReceived, uint256 amountOut); + + function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "handleGatewayMessage", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "message", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "event", + "name": "TokenOutput", + "inputs": [ + { + "name": "tokenReceived", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "amountOut", + "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 IStrategy { + use super::*; + use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. +```solidity +event TokenOutput(address tokenReceived, uint256 amountOut); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct TokenOutput { + #[allow(missing_docs)] + pub tokenReceived: alloy::sol_types::private::Address, + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for TokenOutput { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + tokenReceived: data.0, + amountOut: data.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.tokenReceived, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountOut), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 TokenOutput { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&TokenOutput> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. +```solidity +function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub message: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ); + #[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, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.message) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + message: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageCall { + 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, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; + const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.message, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + ///Container for all the [`IStrategy`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum IStrategyCalls { + #[allow(missing_docs)] + handleGatewayMessage(handleGatewayMessageCall), + } + #[automatically_derived] + impl IStrategyCalls { + /// 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, 99u8, 76u8, 14u8]]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for IStrategyCalls { + const NAME: &'static str = "IStrategyCalls"; + const MIN_DATA_LENGTH: usize = 160usize; + const COUNT: usize = 1usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::handleGatewayMessage(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::handleGatewayMessage(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::handleGatewayMessage(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`IStrategy`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum IStrategyEvents { + #[allow(missing_docs)] + TokenOutput(TokenOutput), + } + #[automatically_derived] + impl IStrategyEvents { + /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for IStrategyEvents { + const NAME: &'static str = "IStrategyEvents"; + const COUNT: usize = 1usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::TokenOutput) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 IStrategyEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`IStrategy`](self) contract instance. + +See the [wrapper's documentation](`IStrategyInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> IStrategyInstance { + IStrategyInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + IStrategyInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + IStrategyInstance::::deploy_builder(provider) + } + /**A [`IStrategy`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`IStrategy`](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 IStrategyInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for IStrategyInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("IStrategyInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IStrategyInstance { + /**Creates a new wrapper around an on-chain [`IStrategy`](self) contract instance. + +See the [wrapper's documentation](`IStrategyInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 IStrategyInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> IStrategyInstance { + IStrategyInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IStrategyInstance { + /// 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( + &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 [`handleGatewayMessage`] function. + pub fn handleGatewayMessage( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + message: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { + self.call_builder( + &handleGatewayMessageCall { + tokenSent, + amountIn, + recipient, + message, + }, + ) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IStrategyInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`TokenOutput`] event. + pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/i_strategy_with_slippage_args.rs b/crates/bindings/src/i_strategy_with_slippage_args.rs new file mode 100644 index 000000000..9c26d79c1 --- /dev/null +++ b/crates/bindings/src/i_strategy_with_slippage_args.rs @@ -0,0 +1,1275 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface IStrategyWithSlippageArgs { + struct StrategySlippageArgs { + uint256 amountOutMin; + } + + event TokenOutput(address tokenReceived, uint256 amountOut); + + function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; + function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "handleGatewayMessage", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "message", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessageWithSlippageArgs", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "args", + "type": "tuple", + "internalType": "struct StrategySlippageArgs", + "components": [ + { + "name": "amountOutMin", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "event", + "name": "TokenOutput", + "inputs": [ + { + "name": "tokenReceived", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "amountOut", + "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 IStrategyWithSlippageArgs { + use super::*; + use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct StrategySlippageArgs { uint256 amountOutMin; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct StrategySlippageArgs { + #[allow(missing_docs)] + pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: StrategySlippageArgs) -> Self { + (value.amountOutMin,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for StrategySlippageArgs { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { amountOutMin: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for StrategySlippageArgs { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for StrategySlippageArgs { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for StrategySlippageArgs { + const NAME: &'static str = "StrategySlippageArgs"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "StrategySlippageArgs(uint256 amountOutMin)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) + .0 + .to_vec() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for StrategySlippageArgs { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.amountOutMin, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.amountOutMin, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. +```solidity +event TokenOutput(address tokenReceived, uint256 amountOut); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct TokenOutput { + #[allow(missing_docs)] + pub tokenReceived: alloy::sol_types::private::Address, + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for TokenOutput { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + tokenReceived: data.0, + amountOut: data.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.tokenReceived, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountOut), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 TokenOutput { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&TokenOutput> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. +```solidity +function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub message: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ); + #[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, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.message) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + message: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageCall { + 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, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; + const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.message, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. +```solidity +function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub args: ::RustType, + } + ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Address, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.args) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + args: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageWithSlippageArgsReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageWithSlippageArgsReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; + const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.args, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + ///Container for all the [`IStrategyWithSlippageArgs`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum IStrategyWithSlippageArgsCalls { + #[allow(missing_docs)] + handleGatewayMessage(handleGatewayMessageCall), + #[allow(missing_docs)] + handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), + } + #[automatically_derived] + impl IStrategyWithSlippageArgsCalls { + /// 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, 99u8, 76u8, 14u8], + [127u8, 129u8, 79u8, 53u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for IStrategyWithSlippageArgsCalls { + const NAME: &'static str = "IStrategyWithSlippageArgsCalls"; + const MIN_DATA_LENGTH: usize = 128usize; + const COUNT: usize = 2usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::handleGatewayMessage(_) => { + ::SELECTOR + } + Self::handleGatewayMessageWithSlippageArgs(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IStrategyWithSlippageArgsCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + IStrategyWithSlippageArgsCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IStrategyWithSlippageArgsCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + IStrategyWithSlippageArgsCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::handleGatewayMessage(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::handleGatewayMessage(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`IStrategyWithSlippageArgs`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum IStrategyWithSlippageArgsEvents { + #[allow(missing_docs)] + TokenOutput(TokenOutput), + } + #[automatically_derived] + impl IStrategyWithSlippageArgsEvents { + /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for IStrategyWithSlippageArgsEvents { + const NAME: &'static str = "IStrategyWithSlippageArgsEvents"; + const COUNT: usize = 1usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::TokenOutput) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 IStrategyWithSlippageArgsEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`IStrategyWithSlippageArgs`](self) contract instance. + +See the [wrapper's documentation](`IStrategyWithSlippageArgsInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> IStrategyWithSlippageArgsInstance { + IStrategyWithSlippageArgsInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + IStrategyWithSlippageArgsInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + IStrategyWithSlippageArgsInstance::::deploy_builder(provider) + } + /**A [`IStrategyWithSlippageArgs`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`IStrategyWithSlippageArgs`](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 IStrategyWithSlippageArgsInstance< + P, + N = alloy_contract::private::Ethereum, + > { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for IStrategyWithSlippageArgsInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("IStrategyWithSlippageArgsInstance") + .field(&self.address) + .finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IStrategyWithSlippageArgsInstance { + /**Creates a new wrapper around an on-chain [`IStrategyWithSlippageArgs`](self) contract instance. + +See the [wrapper's documentation](`IStrategyWithSlippageArgsInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 IStrategyWithSlippageArgsInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> IStrategyWithSlippageArgsInstance { + IStrategyWithSlippageArgsInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IStrategyWithSlippageArgsInstance { + /// 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( + &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 [`handleGatewayMessage`] function. + pub fn handleGatewayMessage( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + message: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { + self.call_builder( + &handleGatewayMessageCall { + tokenSent, + amountIn, + recipient, + message, + }, + ) + } + ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. + pub fn handleGatewayMessageWithSlippageArgs( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + args: ::RustType, + ) -> alloy_contract::SolCallBuilder< + &P, + handleGatewayMessageWithSlippageArgsCall, + N, + > { + self.call_builder( + &handleGatewayMessageWithSlippageArgsCall { + tokenSent, + amountIn, + recipient, + args, + }, + ) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IStrategyWithSlippageArgsInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`TokenOutput`] event. + pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/i_teller.rs b/crates/bindings/src/i_teller.rs new file mode 100644 index 000000000..419e9e4e0 --- /dev/null +++ b/crates/bindings/src/i_teller.rs @@ -0,0 +1,547 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface ITeller { + function deposit(address depositAsset, uint256 depositAmount, uint256 minimumMint) external payable returns (uint256 shares); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "deposit", + "inputs": [ + { + "name": "depositAsset", + "type": "address", + "internalType": "contract ERC20" + }, + { + "name": "depositAmount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "minimumMint", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "shares", + "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 ITeller { + use super::*; + use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `deposit(address,uint256,uint256)` and selector `0x0efe6a8b`. +```solidity +function deposit(address depositAsset, uint256 depositAmount, uint256 minimumMint) external payable returns (uint256 shares); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct depositCall { + #[allow(missing_docs)] + pub depositAsset: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub depositAmount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub minimumMint: alloy::sol_types::private::primitives::aliases::U256, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///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(missing_docs)] + pub shares: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: depositCall) -> Self { + (value.depositAsset, value.depositAmount, value.minimumMint) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for depositCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + depositAsset: tuple.0, + depositAmount: tuple.1, + minimumMint: tuple.2, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: depositReturn) -> Self { + (value.shares,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for depositReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { shares: tuple.0 } + } + } + } + #[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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "deposit(address,uint256,uint256)"; + const SELECTOR: [u8; 4] = [14u8, 254u8, 106u8, 139u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.depositAsset, + ), + as alloy_sol_types::SolType>::tokenize(&self.depositAmount), + as alloy_sol_types::SolType>::tokenize(&self.minimumMint), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: depositReturn = r.into(); + r.shares + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: depositReturn = r.into(); + r.shares + }) + } + } + }; + ///Container for all the [`ITeller`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum ITellerCalls { + #[allow(missing_docs)] + deposit(depositCall), + } + #[automatically_derived] + impl ITellerCalls { + /// 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]]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for ITellerCalls { + const NAME: &'static str = "ITellerCalls"; + const MIN_DATA_LENGTH: usize = 96usize; + const COUNT: usize = 1usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::deposit(_) => ::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 { + static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result] = &[ + { + fn deposit(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ITellerCalls::deposit) + } + deposit + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn deposit(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ITellerCalls::deposit) + } + deposit + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::deposit(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::deposit(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`ITeller`](self) contract instance. + +See the [wrapper's documentation](`ITellerInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >(address: alloy_sol_types::private::Address, provider: P) -> ITellerInstance { + ITellerInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + ITellerInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + ITellerInstance::::deploy_builder(provider) + } + /**A [`ITeller`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`ITeller`](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 ITellerInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for ITellerInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("ITellerInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ITellerInstance { + /**Creates a new wrapper around an on-chain [`ITeller`](self) contract instance. + +See the [wrapper's documentation](`ITellerInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 ITellerInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> ITellerInstance { + ITellerInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ITellerInstance { + /// 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( + &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 [`deposit`] function. + pub fn deposit( + &self, + depositAsset: alloy::sol_types::private::Address, + depositAmount: alloy::sol_types::private::primitives::aliases::U256, + minimumMint: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, depositCall, N> { + self.call_builder( + &depositCall { + depositAsset, + depositAmount, + minimumMint, + }, + ) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ITellerInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/ic_erc20.rs b/crates/bindings/src/ic_erc20.rs new file mode 100644 index 000000000..ef61d26dc --- /dev/null +++ b/crates/bindings/src/ic_erc20.rs @@ -0,0 +1,729 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface ICErc20 { + function balanceOfUnderlying(address owner) external returns (uint256); + function mint(uint256 mintAmount) external returns (uint256); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "balanceOfUnderlying", + "inputs": [ + { + "name": "owner", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "mint", + "inputs": [ + { + "name": "mintAmount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "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 ICErc20 { + use super::*; + use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `balanceOfUnderlying(address)` and selector `0x3af9e669`. +```solidity +function balanceOfUnderlying(address owner) external returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct balanceOfUnderlyingCall { + #[allow(missing_docs)] + pub owner: alloy::sol_types::private::Address, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`balanceOfUnderlying(address)`](balanceOfUnderlyingCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct balanceOfUnderlyingReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: balanceOfUnderlyingCall) -> Self { + (value.owner,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for balanceOfUnderlyingCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { owner: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: balanceOfUnderlyingReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for balanceOfUnderlyingReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for balanceOfUnderlyingCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "balanceOfUnderlying(address)"; + const SELECTOR: [u8; 4] = [58u8, 249u8, 230u8, 105u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.owner, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: balanceOfUnderlyingReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: balanceOfUnderlyingReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `mint(uint256)` and selector `0xa0712d68`. +```solidity +function mint(uint256 mintAmount) external returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct mintCall { + #[allow(missing_docs)] + pub mintAmount: alloy::sol_types::private::primitives::aliases::U256, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`mint(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: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: mintCall) -> Self { + (value.mintAmount,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for mintCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { mintAmount: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: mintReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "mint(uint256)"; + const SELECTOR: [u8; 4] = [160u8, 113u8, 45u8, 104u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.mintAmount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: mintReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`ICErc20`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum ICErc20Calls { + #[allow(missing_docs)] + balanceOfUnderlying(balanceOfUnderlyingCall), + #[allow(missing_docs)] + mint(mintCall), + } + #[automatically_derived] + impl ICErc20Calls { + /// 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]] = &[ + [58u8, 249u8, 230u8, 105u8], + [160u8, 113u8, 45u8, 104u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for ICErc20Calls { + const NAME: &'static str = "ICErc20Calls"; + const MIN_DATA_LENGTH: usize = 32usize; + const COUNT: usize = 2usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::balanceOfUnderlying(_) => { + ::SELECTOR + } + Self::mint(_) => ::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 { + static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result] = &[ + { + fn balanceOfUnderlying( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ICErc20Calls::balanceOfUnderlying) + } + balanceOfUnderlying + }, + { + fn mint(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ICErc20Calls::mint) + } + mint + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn balanceOfUnderlying( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ICErc20Calls::balanceOfUnderlying) + } + balanceOfUnderlying + }, + { + fn mint(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ICErc20Calls::mint) + } + mint + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::balanceOfUnderlying(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::mint(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::balanceOfUnderlying(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::mint(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`ICErc20`](self) contract instance. + +See the [wrapper's documentation](`ICErc20Instance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >(address: alloy_sol_types::private::Address, provider: P) -> ICErc20Instance { + ICErc20Instance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + ICErc20Instance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + ICErc20Instance::::deploy_builder(provider) + } + /**A [`ICErc20`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`ICErc20`](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 ICErc20Instance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for ICErc20Instance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("ICErc20Instance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ICErc20Instance { + /**Creates a new wrapper around an on-chain [`ICErc20`](self) contract instance. + +See the [wrapper's documentation](`ICErc20Instance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 ICErc20Instance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> ICErc20Instance { + ICErc20Instance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ICErc20Instance { + /// 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( + &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 [`balanceOfUnderlying`] function. + pub fn balanceOfUnderlying( + &self, + owner: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, balanceOfUnderlyingCall, N> { + self.call_builder(&balanceOfUnderlyingCall { owner }) + } + ///Creates a new call builder for the [`mint`] function. + pub fn mint( + &self, + mintAmount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> { + self.call_builder(&mintCall { mintAmount }) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ICErc20Instance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/ierc20.rs b/crates/bindings/src/ierc20.rs new file mode 100644 index 000000000..d3ac2fdb4 --- /dev/null +++ b/crates/bindings/src/ierc20.rs @@ -0,0 +1,2049 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface IERC20 { + event Approval(address indexed owner, address indexed spender, uint256 value); + event Transfer(address indexed from, address indexed to, uint256 value); + + 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 totalSupply() 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": "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": "totalSupply", + "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" + }, + { + "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 IERC20 { + use super::*; + use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Approval { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + 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, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + owner: topics.1, + spender: topics.2, + value: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.value), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.owner, + ); + out[2usize] = ::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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Transfer { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + 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, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + from: topics.1, + to: topics.2, + value: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.value), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.from, + ); + out[2usize] = ::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(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: allowanceCall) -> Self { + (value.owner, value.spender) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for allowanceCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + owner: tuple.0, + spender: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: allowanceReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "allowance(address,address)"; + const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.owner, + ), + ::tokenize( + &self.spender, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: allowanceReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: approveCall) -> Self { + (value.spender, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for approveCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + spender: tuple.0, + amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: approveReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "approve(address,uint256)"; + const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.spender, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: approveReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: balanceOfCall) -> Self { + (value.account,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for balanceOfCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { account: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: balanceOfReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "balanceOf(address)"; + const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.account, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: balanceOfReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: totalSupplyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for totalSupplyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: totalSupplyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for totalSupplyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for totalSupplyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "totalSupply()"; + const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: totalSupplyReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferCall) -> Self { + (value.to, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for transferCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + to: tuple.0, + amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transfer(address,uint256)"; + const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.to, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: transferReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferFromCall) -> Self { + (value.from, value.to, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for transferFromCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + from: tuple.0, + to: tuple.1, + amount: tuple.2, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferFromReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transferFrom(address,address,uint256)"; + const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.from, + ), + ::tokenize( + &self.to, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: transferFromReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`IERC20`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum IERC20Calls { + #[allow(missing_docs)] + allowance(allowanceCall), + #[allow(missing_docs)] + approve(approveCall), + #[allow(missing_docs)] + balanceOf(balanceOfCall), + #[allow(missing_docs)] + totalSupply(totalSupplyCall), + #[allow(missing_docs)] + transfer(transferCall), + #[allow(missing_docs)] + transferFrom(transferFromCall), + } + #[automatically_derived] + impl IERC20Calls { + /// 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], + [112u8, 160u8, 130u8, 49u8], + [169u8, 5u8, 156u8, 187u8], + [221u8, 98u8, 237u8, 62u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for IERC20Calls { + const NAME: &'static str = "IERC20Calls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 6usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::allowance(_) => { + ::SELECTOR + } + Self::approve(_) => ::SELECTOR, + Self::balanceOf(_) => { + ::SELECTOR + } + Self::totalSupply(_) => { + ::SELECTOR + } + Self::transfer(_) => ::SELECTOR, + Self::transferFrom(_) => { + ::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 { + static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result] = &[ + { + fn approve(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IERC20Calls::approve) + } + approve + }, + { + fn totalSupply(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IERC20Calls::totalSupply) + } + totalSupply + }, + { + fn transferFrom( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IERC20Calls::transferFrom) + } + transferFrom + }, + { + fn balanceOf(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IERC20Calls::balanceOf) + } + balanceOf + }, + { + fn transfer(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IERC20Calls::transfer) + } + transfer + }, + { + fn allowance(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IERC20Calls::allowance) + } + allowance + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn approve(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IERC20Calls::approve) + } + approve + }, + { + fn totalSupply(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IERC20Calls::totalSupply) + } + totalSupply + }, + { + fn transferFrom( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IERC20Calls::transferFrom) + } + transferFrom + }, + { + fn balanceOf(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IERC20Calls::balanceOf) + } + balanceOf + }, + { + fn transfer(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IERC20Calls::transfer) + } + transfer + }, + { + fn allowance(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IERC20Calls::allowance) + } + allowance + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::allowance(inner) => { + ::abi_encoded_size(inner) + } + Self::approve(inner) => { + ::abi_encoded_size(inner) + } + Self::balanceOf(inner) => { + ::abi_encoded_size(inner) + } + Self::totalSupply(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::transfer(inner) => { + ::abi_encoded_size(inner) + } + Self::transferFrom(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::allowance(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::approve(inner) => { + ::abi_encode_raw(inner, out) + } + Self::balanceOf(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::totalSupply(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transfer(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transferFrom(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`IERC20`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum IERC20Events { + #[allow(missing_docs)] + Approval(Approval), + #[allow(missing_docs)] + Transfer(Transfer), + } + #[automatically_derived] + impl IERC20Events { + /// 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, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for IERC20Events { + const NAME: &'static str = "IERC20Events"; + const COUNT: usize = 2usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Approval) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Transfer) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 IERC20Events { + 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 as alloy_contract; + /**Creates a new wrapper around an on-chain [`IERC20`](self) contract instance. + +See the [wrapper's documentation](`IERC20Instance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >(address: alloy_sol_types::private::Address, provider: P) -> IERC20Instance { + IERC20Instance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + IERC20Instance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + IERC20Instance::::deploy_builder(provider) + } + /**A [`IERC20`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`IERC20`](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 IERC20Instance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for IERC20Instance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("IERC20Instance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IERC20Instance { + /**Creates a new wrapper around an on-chain [`IERC20`](self) contract instance. + +See the [wrapper's documentation](`IERC20Instance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 IERC20Instance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> IERC20Instance { + IERC20Instance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IERC20Instance { + /// 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( + &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 [`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, + 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. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IERC20Instance { + /// 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( + &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::() + } + ///Creates a new event filter for the [`Transfer`] event. + pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/ierc20_metadata.rs b/crates/bindings/src/ierc20_metadata.rs new file mode 100644 index 000000000..10d467cdb --- /dev/null +++ b/crates/bindings/src/ierc20_metadata.rs @@ -0,0 +1,2650 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface IERC20Metadata { + event Approval(address indexed owner, address indexed spender, uint256 value); + event Transfer(address indexed from, address indexed to, uint256 value); + + 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 name() external view returns (string memory); + function symbol() external view returns (string memory); + function totalSupply() 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": "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": "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": "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" + }, + { + "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 IERC20Metadata { + use super::*; + use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Approval { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + 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, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + owner: topics.1, + spender: topics.2, + value: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.value), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.owner, + ); + out[2usize] = ::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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Transfer { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + 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, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + from: topics.1, + to: topics.2, + value: data.0, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.value), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.from, + ); + out[2usize] = ::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(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: allowanceCall) -> Self { + (value.owner, value.spender) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for allowanceCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + owner: tuple.0, + spender: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: allowanceReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "allowance(address,address)"; + const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.owner, + ), + ::tokenize( + &self.spender, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: allowanceReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: approveCall) -> Self { + (value.spender, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for approveCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + spender: tuple.0, + amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: approveReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "approve(address,uint256)"; + const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.spender, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: approveReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: balanceOfCall) -> Self { + (value.account,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for balanceOfCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { account: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: balanceOfReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "balanceOf(address)"; + const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.account, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: balanceOfReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: decimalsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for decimalsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: decimalsReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for decimalsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for decimalsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = u8; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "decimals()"; + const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: decimalsReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: nameCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for nameCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: nameReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for nameReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for nameCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::String; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "name()"; + const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: nameReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: symbolCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for symbolCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: symbolReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for symbolReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for symbolCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::String; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "symbol()"; + const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: symbolReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: totalSupplyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for totalSupplyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: totalSupplyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for totalSupplyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for totalSupplyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "totalSupply()"; + const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: totalSupplyReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferCall) -> Self { + (value.to, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for transferCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + to: tuple.0, + amount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transfer(address,uint256)"; + const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.to, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: transferReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferFromCall) -> Self { + (value.from, value.to, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for transferFromCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + from: tuple.0, + to: tuple.1, + amount: tuple.2, + } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: transferFromReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transferFrom(address,address,uint256)"; + const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.from, + ), + ::tokenize( + &self.to, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: transferFromReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`IERC20Metadata`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum IERC20MetadataCalls { + #[allow(missing_docs)] + allowance(allowanceCall), + #[allow(missing_docs)] + approve(approveCall), + #[allow(missing_docs)] + balanceOf(balanceOfCall), + #[allow(missing_docs)] + decimals(decimalsCall), + #[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), + } + #[automatically_derived] + impl IERC20MetadataCalls { + /// 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], + [112u8, 160u8, 130u8, 49u8], + [149u8, 216u8, 155u8, 65u8], + [169u8, 5u8, 156u8, 187u8], + [221u8, 98u8, 237u8, 62u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for IERC20MetadataCalls { + const NAME: &'static str = "IERC20MetadataCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 9usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::allowance(_) => { + ::SELECTOR + } + Self::approve(_) => ::SELECTOR, + Self::balanceOf(_) => { + ::SELECTOR + } + Self::decimals(_) => ::SELECTOR, + Self::name(_) => ::SELECTOR, + Self::symbol(_) => ::SELECTOR, + Self::totalSupply(_) => { + ::SELECTOR + } + Self::transfer(_) => ::SELECTOR, + Self::transferFrom(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn name( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IERC20MetadataCalls::name) + } + name + }, + { + fn approve( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IERC20MetadataCalls::approve) + } + approve + }, + { + fn totalSupply( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IERC20MetadataCalls::totalSupply) + } + totalSupply + }, + { + fn transferFrom( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IERC20MetadataCalls::transferFrom) + } + transferFrom + }, + { + fn decimals( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IERC20MetadataCalls::decimals) + } + decimals + }, + { + fn balanceOf( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IERC20MetadataCalls::balanceOf) + } + balanceOf + }, + { + fn symbol( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IERC20MetadataCalls::symbol) + } + symbol + }, + { + fn transfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IERC20MetadataCalls::transfer) + } + transfer + }, + { + fn allowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IERC20MetadataCalls::allowance) + } + allowance + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn name( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IERC20MetadataCalls::name) + } + name + }, + { + fn approve( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IERC20MetadataCalls::approve) + } + approve + }, + { + fn totalSupply( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IERC20MetadataCalls::totalSupply) + } + totalSupply + }, + { + fn transferFrom( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IERC20MetadataCalls::transferFrom) + } + transferFrom + }, + { + fn decimals( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IERC20MetadataCalls::decimals) + } + decimals + }, + { + fn balanceOf( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IERC20MetadataCalls::balanceOf) + } + balanceOf + }, + { + fn symbol( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IERC20MetadataCalls::symbol) + } + symbol + }, + { + fn transfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IERC20MetadataCalls::transfer) + } + transfer + }, + { + fn allowance( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IERC20MetadataCalls::allowance) + } + allowance + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::allowance(inner) => { + ::abi_encoded_size(inner) + } + Self::approve(inner) => { + ::abi_encoded_size(inner) + } + Self::balanceOf(inner) => { + ::abi_encoded_size(inner) + } + Self::decimals(inner) => { + ::abi_encoded_size(inner) + } + Self::name(inner) => { + ::abi_encoded_size(inner) + } + Self::symbol(inner) => { + ::abi_encoded_size(inner) + } + Self::totalSupply(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::transfer(inner) => { + ::abi_encoded_size(inner) + } + Self::transferFrom(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::allowance(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::approve(inner) => { + ::abi_encode_raw(inner, out) + } + Self::balanceOf(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::decimals(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::name(inner) => { + ::abi_encode_raw(inner, out) + } + Self::symbol(inner) => { + ::abi_encode_raw(inner, out) + } + Self::totalSupply(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transfer(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transferFrom(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`IERC20Metadata`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum IERC20MetadataEvents { + #[allow(missing_docs)] + Approval(Approval), + #[allow(missing_docs)] + Transfer(Transfer), + } + #[automatically_derived] + impl IERC20MetadataEvents { + /// 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, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for IERC20MetadataEvents { + const NAME: &'static str = "IERC20MetadataEvents"; + const COUNT: usize = 2usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Approval) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Transfer) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 IERC20MetadataEvents { + 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 as alloy_contract; + /**Creates a new wrapper around an on-chain [`IERC20Metadata`](self) contract instance. + +See the [wrapper's documentation](`IERC20MetadataInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> IERC20MetadataInstance { + IERC20MetadataInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + IERC20MetadataInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + IERC20MetadataInstance::::deploy_builder(provider) + } + /**A [`IERC20Metadata`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`IERC20Metadata`](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 IERC20MetadataInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for IERC20MetadataInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("IERC20MetadataInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IERC20MetadataInstance { + /**Creates a new wrapper around an on-chain [`IERC20Metadata`](self) contract instance. + +See the [wrapper's documentation](`IERC20MetadataInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 IERC20MetadataInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> IERC20MetadataInstance { + IERC20MetadataInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IERC20MetadataInstance { + /// 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( + &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 [`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, + 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. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IERC20MetadataInstance { + /// 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( + &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::() + } + ///Creates a new event filter for the [`Transfer`] event. + pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/ierc2771_recipient.rs b/crates/bindings/src/ierc2771_recipient.rs new file mode 100644 index 000000000..29732235a --- /dev/null +++ b/crates/bindings/src/ierc2771_recipient.rs @@ -0,0 +1,527 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface IERC2771Recipient { + function isTrustedForwarder(address forwarder) external view returns (bool); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "isTrustedForwarder", + "inputs": [ + { + "name": "forwarder", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + } +] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod IERC2771Recipient { + use super::*; + use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `isTrustedForwarder(address)` and selector `0x572b6c05`. +```solidity +function isTrustedForwarder(address forwarder) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isTrustedForwarderCall { + #[allow(missing_docs)] + pub forwarder: alloy::sol_types::private::Address, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`isTrustedForwarder(address)`](isTrustedForwarderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isTrustedForwarderReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isTrustedForwarderCall) -> Self { + (value.forwarder,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isTrustedForwarderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { forwarder: tuple.0 } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isTrustedForwarderReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isTrustedForwarderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isTrustedForwarderCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isTrustedForwarder(address)"; + const SELECTOR: [u8; 4] = [87u8, 43u8, 108u8, 5u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.forwarder, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isTrustedForwarderReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isTrustedForwarderReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`IERC2771Recipient`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum IERC2771RecipientCalls { + #[allow(missing_docs)] + isTrustedForwarder(isTrustedForwarderCall), + } + #[automatically_derived] + impl IERC2771RecipientCalls { + /// 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]] = &[[87u8, 43u8, 108u8, 5u8]]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for IERC2771RecipientCalls { + const NAME: &'static str = "IERC2771RecipientCalls"; + const MIN_DATA_LENGTH: usize = 32usize; + const COUNT: usize = 1usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::isTrustedForwarder(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn isTrustedForwarder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IERC2771RecipientCalls::isTrustedForwarder) + } + isTrustedForwarder + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn isTrustedForwarder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IERC2771RecipientCalls::isTrustedForwarder) + } + isTrustedForwarder + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::isTrustedForwarder(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::isTrustedForwarder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`IERC2771Recipient`](self) contract instance. + +See the [wrapper's documentation](`IERC2771RecipientInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> IERC2771RecipientInstance { + IERC2771RecipientInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + IERC2771RecipientInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + IERC2771RecipientInstance::::deploy_builder(provider) + } + /**A [`IERC2771Recipient`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`IERC2771Recipient`](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 IERC2771RecipientInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for IERC2771RecipientInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("IERC2771RecipientInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IERC2771RecipientInstance { + /**Creates a new wrapper around an on-chain [`IERC2771Recipient`](self) contract instance. + +See the [wrapper's documentation](`IERC2771RecipientInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 IERC2771RecipientInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> IERC2771RecipientInstance { + IERC2771RecipientInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IERC2771RecipientInstance { + /// 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( + &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 [`isTrustedForwarder`] function. + pub fn isTrustedForwarder( + &self, + forwarder: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isTrustedForwarderCall, N> { + self.call_builder( + &isTrustedForwarderCall { + forwarder, + }, + ) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IERC2771RecipientInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/ionic_strategy.rs b/crates/bindings/src/ionic_strategy.rs new file mode 100644 index 000000000..3e8c05f85 --- /dev/null +++ b/crates/bindings/src/ionic_strategy.rs @@ -0,0 +1,1767 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface IonicStrategy { + struct StrategySlippageArgs { + uint256 amountOutMin; + } + + event TokenOutput(address tokenReceived, uint256 amountOut); + + constructor(address _ioErc20, address _pool); + + function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; + function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; + function ioErc20() external view returns (address); + function pool() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_ioErc20", + "type": "address", + "internalType": "contract IIonicToken" + }, + { + "name": "_pool", + "type": "address", + "internalType": "contract IPool" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessage", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "message", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessageWithSlippageArgs", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "args", + "type": "tuple", + "internalType": "struct StrategySlippageArgs", + "components": [ + { + "name": "amountOutMin", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "ioErc20", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IIonicToken" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "pool", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IPool" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "TokenOutput", + "inputs": [ + { + "name": "tokenReceived", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "amountOut", + "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 IonicStrategy { + use super::*; + use alloy::sol_types as 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\x11.8\x03\x80a\x11.\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x10Qa\0\xDD_9_\x81\x81`S\x01Ra\x02\xD1\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xBF\x01R\x81\x81a\x02S\x01R\x81\x81a\x03\xE8\x01Ra\x05\xD4\x01Ra\x10Q_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x16\xF0\x11[\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xF6s\xF0\xD9\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\x0C\xB1V[a\0\xEDV[\0[a\0\xB1a\0\xC16`\x04a\rsV[a\x01\x17V[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[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\r\xF7V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x07LV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x08\x10V[`@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\x83\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\x91_\x91\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0E\x1BV[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R\x91\x92P_\x91\x90` \x80\x83\x01\x90\x806\x837\x01\x90PP\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\x81_\x81Q\x81\x10a\x02\x84Wa\x02\x84a\x0E2V[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`@Q\x7F\xC2\x99\x828\0\0\0\0\0\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\x7F\0\0\0\0\0\0\0\0\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\xC2\x99\x828\x90a\x03\x06\x90\x85\x90`\x04\x01a\x0E_V[_`@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03!W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x03H\x91\x90\x81\x01\x90a\x0E\xB7V[\x90P\x80_\x81Q\x81\x10a\x03\\Wa\x03\\a\x0E2V[` \x02` \x01\x01Q_\x14a\x03\xB7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FCouldn't enter in Market\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@Q\x7F\xA0q-h\0\0\0\0\0\0\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\x88\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\xA0q-h\x90`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04g\x91\x90a\x0E\x1BV[\x90P\x80\x15a\x04\xDCW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FCould not mint token in Ionic ma`D\x82\x01R\x7Frket\0\0\0\0\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\x03\xAEV[`@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\x87\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05j\x91\x90a\x0E\x1BV[\x90Pa\x05\x8Ds\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x89\x83a\t\x0BV[`@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\x89\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\x1BW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06?\x91\x90a\x0E\x1BV[\x90P\x85\x81\x11a\x06\x90W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01a\x03\xAEV[_a\x06\x9B\x87\x83a\x0F\x85V[\x89Q\x90\x91P\x81\x10\x15a\x06\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xAEV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8A\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x08\n\x90\x85\x90\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\x90`\x84\x01[`@\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\tfV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x84W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\xA8\x91\x90a\x0E\x1BV[a\x08\xB2\x91\x90a\x0F\x9EV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x08\n\x90\x85\x90\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\x90`d\x01a\x07\xA6V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\ta\x90\x84\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\x90`d\x01a\x07\xA6V[PPPV[_a\t\xC7\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\nW\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\taW\x80\x80` \x01\x90Q\x81\x01\x90a\t\xE5\x91\x90a\x0F\xB1V[a\taW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xAEV[``a\ne\x84\x84_\x85a\noV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\n\xE7W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xAEV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x0BKW`@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\x03\xAEV[__\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\x0Bs\x91\x90a\x0F\xD0V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x0B\xADW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x0B\xB2V[``\x91P[P\x91P\x91Pa\x0B\xC2\x82\x82\x86a\x0B\xCDV[\x97\x96PPPPPPPV[``\x83\x15a\x0B\xDCWP\x81a\nhV[\x82Q\x15a\x0B\xECW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xAE\x91\x90a\x0F\xE6V[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\x0C'W__\xFD[PV[\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\x0CzWa\x0Cza\x0C*V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0C\xA9Wa\x0C\xA9a\x0C*V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0C\xC4W__\xFD[\x845a\x0C\xCF\x81a\x0C\x06V[\x93P` \x85\x015\x92P`@\x85\x015a\x0C\xE6\x81a\x0C\x06V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\x01W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\r\x11W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r+Wa\r+a\x0C*V[a\r>` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0C\x80V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\rRW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\r\x87W__\xFD[\x855a\r\x92\x81a\x0C\x06V[\x94P` \x86\x015\x93P`@\x86\x015a\r\xA9\x81a\x0C\x06V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\r\xDAW__\xFD[Pa\r\xE3a\x0CWV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0E\x08W__\xFD[Pa\x0E\x11a\x0CWV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0E+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[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x0E\xACW\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\x0ExV[P\x90\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x0E\xC7W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0E\xDDW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x0E\xEDW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0F\x07Wa\x0F\x07a\x0C*V[\x80`\x05\x1Ba\x0F\x17` \x82\x01a\x0C\x80V[\x91\x82R` \x81\x84\x01\x81\x01\x92\x90\x81\x01\x90\x87\x84\x11\x15a\x0F2W__\xFD[` \x85\x01\x94P[\x83\x85\x10\x15a\x0B\xC2W\x84Q\x80\x83R` \x95\x86\x01\x95\x90\x93P\x90\x91\x01\x90a\x0F9V[\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\x0F\x98Wa\x0F\x98a\x0FXV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0F\x98Wa\x0F\x98a\x0FXV[_` \x82\x84\x03\x12\x15a\x0F\xC1W__\xFD[\x81Q\x80\x15\x15\x81\x14a\nhW__\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\xFE\xA2dipfsX\"\x12 \xA63\xC5\xE5\xEB@\xCE\xD5\xA8\xAC\xC4\xC9\xF1HKy%\x82\xCD\xE3]\xB9\xCEE\xC8l\xF1O\x15\xEA\xD7\xF0dsolcC\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\x16\xF0\x11[\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xF6s\xF0\xD9\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\x0C\xB1V[a\0\xEDV[\0[a\0\xB1a\0\xC16`\x04a\rsV[a\x01\x17V[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[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\r\xF7V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x07LV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x08\x10V[`@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\x83\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\x91_\x91\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0E\x1BV[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R\x91\x92P_\x91\x90` \x80\x83\x01\x90\x806\x837\x01\x90PP\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\x81_\x81Q\x81\x10a\x02\x84Wa\x02\x84a\x0E2V[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`@Q\x7F\xC2\x99\x828\0\0\0\0\0\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\x7F\0\0\0\0\0\0\0\0\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\xC2\x99\x828\x90a\x03\x06\x90\x85\x90`\x04\x01a\x0E_V[_`@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03!W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x03H\x91\x90\x81\x01\x90a\x0E\xB7V[\x90P\x80_\x81Q\x81\x10a\x03\\Wa\x03\\a\x0E2V[` \x02` \x01\x01Q_\x14a\x03\xB7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FCouldn't enter in Market\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@Q\x7F\xA0q-h\0\0\0\0\0\0\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\x88\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\xA0q-h\x90`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04g\x91\x90a\x0E\x1BV[\x90P\x80\x15a\x04\xDCW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FCould not mint token in Ionic ma`D\x82\x01R\x7Frket\0\0\0\0\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\x03\xAEV[`@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\x87\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05j\x91\x90a\x0E\x1BV[\x90Pa\x05\x8Ds\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x89\x83a\t\x0BV[`@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\x89\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\x1BW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06?\x91\x90a\x0E\x1BV[\x90P\x85\x81\x11a\x06\x90W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01a\x03\xAEV[_a\x06\x9B\x87\x83a\x0F\x85V[\x89Q\x90\x91P\x81\x10\x15a\x06\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xAEV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8A\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x08\n\x90\x85\x90\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\x90`\x84\x01[`@\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\tfV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x84W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\xA8\x91\x90a\x0E\x1BV[a\x08\xB2\x91\x90a\x0F\x9EV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x08\n\x90\x85\x90\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\x90`d\x01a\x07\xA6V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\ta\x90\x84\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\x90`d\x01a\x07\xA6V[PPPV[_a\t\xC7\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\nW\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\taW\x80\x80` \x01\x90Q\x81\x01\x90a\t\xE5\x91\x90a\x0F\xB1V[a\taW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xAEV[``a\ne\x84\x84_\x85a\noV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\n\xE7W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xAEV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x0BKW`@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\x03\xAEV[__\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\x0Bs\x91\x90a\x0F\xD0V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x0B\xADW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x0B\xB2V[``\x91P[P\x91P\x91Pa\x0B\xC2\x82\x82\x86a\x0B\xCDV[\x97\x96PPPPPPPV[``\x83\x15a\x0B\xDCWP\x81a\nhV[\x82Q\x15a\x0B\xECW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xAE\x91\x90a\x0F\xE6V[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\x0C'W__\xFD[PV[\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\x0CzWa\x0Cza\x0C*V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0C\xA9Wa\x0C\xA9a\x0C*V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0C\xC4W__\xFD[\x845a\x0C\xCF\x81a\x0C\x06V[\x93P` \x85\x015\x92P`@\x85\x015a\x0C\xE6\x81a\x0C\x06V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\x01W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\r\x11W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r+Wa\r+a\x0C*V[a\r>` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0C\x80V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\rRW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\r\x87W__\xFD[\x855a\r\x92\x81a\x0C\x06V[\x94P` \x86\x015\x93P`@\x86\x015a\r\xA9\x81a\x0C\x06V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\r\xDAW__\xFD[Pa\r\xE3a\x0CWV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0E\x08W__\xFD[Pa\x0E\x11a\x0CWV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0E+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[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x0E\xACW\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\x0ExV[P\x90\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x0E\xC7W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0E\xDDW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x0E\xEDW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0F\x07Wa\x0F\x07a\x0C*V[\x80`\x05\x1Ba\x0F\x17` \x82\x01a\x0C\x80V[\x91\x82R` \x81\x84\x01\x81\x01\x92\x90\x81\x01\x90\x87\x84\x11\x15a\x0F2W__\xFD[` \x85\x01\x94P[\x83\x85\x10\x15a\x0B\xC2W\x84Q\x80\x83R` \x95\x86\x01\x95\x90\x93P\x90\x91\x01\x90a\x0F9V[\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\x0F\x98Wa\x0F\x98a\x0FXV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0F\x98Wa\x0F\x98a\x0FXV[_` \x82\x84\x03\x12\x15a\x0F\xC1W__\xFD[\x81Q\x80\x15\x15\x81\x14a\nhW__\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\xFE\xA2dipfsX\"\x12 \xA63\xC5\xE5\xEB@\xCE\xD5\xA8\xAC\xC4\xC9\xF1HKy%\x82\xCD\xE3]\xB9\xCEE\xC8l\xF1O\x15\xEA\xD7\xF0dsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct StrategySlippageArgs { uint256 amountOutMin; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct StrategySlippageArgs { + #[allow(missing_docs)] + pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: StrategySlippageArgs) -> Self { + (value.amountOutMin,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for StrategySlippageArgs { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { amountOutMin: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for StrategySlippageArgs { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for StrategySlippageArgs { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for StrategySlippageArgs { + const NAME: &'static str = "StrategySlippageArgs"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "StrategySlippageArgs(uint256 amountOutMin)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) + .0 + .to_vec() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for StrategySlippageArgs { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.amountOutMin, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.amountOutMin, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. +```solidity +event TokenOutput(address tokenReceived, uint256 amountOut); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct TokenOutput { + #[allow(missing_docs)] + pub tokenReceived: alloy::sol_types::private::Address, + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for TokenOutput { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + tokenReceived: data.0, + amountOut: data.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.tokenReceived, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountOut), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 TokenOutput { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&TokenOutput> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(address _ioErc20, address _pool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _ioErc20: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _pool: alloy::sol_types::private::Address, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._ioErc20, value._pool) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _ioErc20: tuple.0, + _pool: 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> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._ioErc20, + ), + ::tokenize( + &self._pool, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. +```solidity +function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub message: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ); + #[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, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.message) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + message: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageCall { + 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, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; + const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.message, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. +```solidity +function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub args: ::RustType, + } + ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Address, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.args) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + args: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageWithSlippageArgsReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageWithSlippageArgsReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; + const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.args, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `ioErc20()` and selector `0xf673f0d9`. +```solidity +function ioErc20() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ioErc20Call; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`ioErc20()`](ioErc20Call) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ioErc20Return { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ioErc20Call) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ioErc20Call { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ioErc20Return) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ioErc20Return { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for ioErc20Call { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ioErc20()"; + const SELECTOR: [u8; 4] = [246u8, 115u8, 240u8, 217u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: ioErc20Return = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: ioErc20Return = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `pool()` and selector `0x16f0115b`. +```solidity +function pool() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct poolCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`pool()`](poolCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct poolReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: poolCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for poolCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: poolReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for poolReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for poolCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "pool()"; + const SELECTOR: [u8; 4] = [22u8, 240u8, 17u8, 91u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: poolReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: poolReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`IonicStrategy`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum IonicStrategyCalls { + #[allow(missing_docs)] + handleGatewayMessage(handleGatewayMessageCall), + #[allow(missing_docs)] + handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), + #[allow(missing_docs)] + ioErc20(ioErc20Call), + #[allow(missing_docs)] + pool(poolCall), + } + #[automatically_derived] + impl IonicStrategyCalls { + /// 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, 240u8, 17u8, 91u8], + [80u8, 99u8, 76u8, 14u8], + [127u8, 129u8, 79u8, 53u8], + [246u8, 115u8, 240u8, 217u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for IonicStrategyCalls { + const NAME: &'static str = "IonicStrategyCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 4usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::handleGatewayMessage(_) => { + ::SELECTOR + } + Self::handleGatewayMessageWithSlippageArgs(_) => { + ::SELECTOR + } + Self::ioErc20(_) => ::SELECTOR, + Self::pool(_) => ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn pool(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IonicStrategyCalls::pool) + } + pool + }, + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IonicStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + IonicStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + { + fn ioErc20( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IonicStrategyCalls::ioErc20) + } + ioErc20 + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn pool(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IonicStrategyCalls::pool) + } + pool + }, + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IonicStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + IonicStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + { + fn ioErc20( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IonicStrategyCalls::ioErc20) + } + ioErc20 + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::handleGatewayMessage(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ioErc20(inner) => { + ::abi_encoded_size(inner) + } + Self::pool(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::handleGatewayMessage(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ioErc20(inner) => { + ::abi_encode_raw(inner, out) + } + Self::pool(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + ///Container for all the [`IonicStrategy`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum IonicStrategyEvents { + #[allow(missing_docs)] + TokenOutput(TokenOutput), + } + #[automatically_derived] + impl IonicStrategyEvents { + /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for IonicStrategyEvents { + const NAME: &'static str = "IonicStrategyEvents"; + const COUNT: usize = 1usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::TokenOutput) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 IonicStrategyEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`IonicStrategy`](self) contract instance. + +See the [wrapper's documentation](`IonicStrategyInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> IonicStrategyInstance { + IonicStrategyInstance::::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: alloy_contract::private::Network, + >( + provider: P, + _ioErc20: alloy::sol_types::private::Address, + _pool: alloy::sol_types::private::Address, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + IonicStrategyInstance::::deploy(provider, _ioErc20, _pool) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + _ioErc20: alloy::sol_types::private::Address, + _pool: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + IonicStrategyInstance::::deploy_builder(provider, _ioErc20, _pool) + } + /**A [`IonicStrategy`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`IonicStrategy`](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 IonicStrategyInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for IonicStrategyInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("IonicStrategyInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IonicStrategyInstance { + /**Creates a new wrapper around an on-chain [`IonicStrategy`](self) contract instance. + +See the [wrapper's documentation](`IonicStrategyInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + _ioErc20: alloy::sol_types::private::Address, + _pool: alloy::sol_types::private::Address, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(provider, _ioErc20, _pool); + 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, + _ioErc20: alloy::sol_types::private::Address, + _pool: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { _ioErc20, _pool }, + )[..], + ] + .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 IonicStrategyInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> IonicStrategyInstance { + IonicStrategyInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IonicStrategyInstance { + /// 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( + &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 [`handleGatewayMessage`] function. + pub fn handleGatewayMessage( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + message: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { + self.call_builder( + &handleGatewayMessageCall { + tokenSent, + amountIn, + recipient, + message, + }, + ) + } + ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. + pub fn handleGatewayMessageWithSlippageArgs( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + args: ::RustType, + ) -> alloy_contract::SolCallBuilder< + &P, + handleGatewayMessageWithSlippageArgsCall, + N, + > { + self.call_builder( + &handleGatewayMessageWithSlippageArgsCall { + tokenSent, + amountIn, + recipient, + args, + }, + ) + } + ///Creates a new call builder for the [`ioErc20`] function. + pub fn ioErc20(&self) -> alloy_contract::SolCallBuilder<&P, ioErc20Call, N> { + self.call_builder(&ioErc20Call) + } + ///Creates a new call builder for the [`pool`] function. + pub fn pool(&self) -> alloy_contract::SolCallBuilder<&P, poolCall, N> { + self.call_builder(&poolCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IonicStrategyInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`TokenOutput`] event. + pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/ionic_strategy_forked.rs b/crates/bindings/src/ionic_strategy_forked.rs new file mode 100644 index 000000000..b3569a814 --- /dev/null +++ b/crates/bindings/src/ionic_strategy_forked.rs @@ -0,0 +1,7991 @@ +///Module containing a contract's types and functions. +/** + +```solidity +library StdInvariant { + struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } + struct FuzzInterface { address addr; string[] artifacts; } + struct FuzzSelector { address addr; bytes4[] selectors; } +} +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod StdInvariant { + use super::*; + use alloy::sol_types as alloy_sol_types; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzArtifactSelector { + #[allow(missing_docs)] + pub artifact: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub selectors: alloy::sol_types::private::Vec< + 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 as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::String, + alloy::sol_types::private::Vec>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzArtifactSelector) -> Self { + (value.artifact, value.selectors) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzArtifactSelector { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + artifact: tuple.0, + selectors: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzArtifactSelector { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.artifact, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.selectors), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzArtifactSelector { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzArtifactSelector { + const NAME: &'static str = "FuzzArtifactSelector"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzArtifactSelector(string artifact,bytes4[] selectors)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.artifact, + ) + .0, + , + > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzArtifactSelector { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.artifact, + ) + + , + > as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.selectors, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.artifact, + out, + ); + , + > as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.selectors, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzInterface { address addr; string[] artifacts; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzInterface { + #[allow(missing_docs)] + pub addr: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub artifacts: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzInterface) -> Self { + (value.addr, value.artifacts) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzInterface { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + addr: tuple.0, + artifacts: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzInterface { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzInterface { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.addr, + ), + as alloy_sol_types::SolType>::tokenize(&self.artifacts), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzInterface { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzInterface { + const NAME: &'static str = "FuzzInterface"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzInterface(address addr,string[] artifacts)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.addr, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzInterface { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.addr, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.artifacts, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.addr, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.artifacts, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzSelector { address addr; bytes4[] selectors; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzSelector { + #[allow(missing_docs)] + pub addr: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub selectors: alloy::sol_types::private::Vec< + 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 as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Vec>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzSelector) -> Self { + (value.addr, value.selectors) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzSelector { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + addr: tuple.0, + selectors: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzSelector { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzSelector { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.addr, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.selectors), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzSelector { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzSelector { + const NAME: &'static str = "FuzzSelector"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzSelector(address addr,bytes4[] selectors)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.addr, + ) + .0, + , + > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzSelector { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.addr, + ) + + , + > as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.selectors, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.addr, + out, + ); + , + > as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.selectors, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. + +See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> StdInvariantInstance { + StdInvariantInstance::::new(address, provider) + } + /**A [`StdInvariant`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`StdInvariant`](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 StdInvariantInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for StdInvariantInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("StdInvariantInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. + +See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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 StdInvariantInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> StdInvariantInstance { + StdInvariantInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} +/** + +Generated by the following Solidity interface... +```solidity +library StdInvariant { + struct FuzzArtifactSelector { + string artifact; + bytes4[] selectors; + } + struct FuzzInterface { + address addr; + string[] artifacts; + } + struct FuzzSelector { + address addr; + bytes4[] selectors; + } +} + +interface IonicStrategyForked { + event log(string); + event log_address(address); + event log_array(uint256[] val); + event log_array(int256[] val); + event log_array(address[] val); + event log_bytes(bytes); + event log_bytes32(bytes32); + event log_int(int256); + event log_named_address(string key, address val); + event log_named_array(string key, uint256[] val); + event log_named_array(string key, int256[] val); + event log_named_array(string key, address[] val); + event log_named_bytes(string key, bytes val); + event log_named_bytes32(string key, bytes32 val); + event log_named_decimal_int(string key, int256 val, uint256 decimals); + event log_named_decimal_uint(string key, uint256 val, uint256 decimals); + event log_named_int(string key, int256 val); + event log_named_string(string key, string val); + event log_named_uint(string key, uint256 val); + event log_string(string); + event log_uint(uint256); + event logs(bytes); + + function IS_TEST() external view returns (bool); + function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); + function excludeContracts() external view returns (address[] memory excludedContracts_); + function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); + function excludeSenders() external view returns (address[] memory excludedSenders_); + function failed() external view returns (bool); + function setUp() external; + function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; + function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); + function targetArtifacts() external view returns (string[] memory targetedArtifacts_); + function targetContracts() external view returns (address[] memory targetedContracts_); + function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); + function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); + function targetSenders() external view returns (address[] memory targetedSenders_); + function testIonicStrategy() external; + function token() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "IS_TEST", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeArtifacts", + "inputs": [], + "outputs": [ + { + "name": "excludedArtifacts_", + "type": "string[]", + "internalType": "string[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeContracts", + "inputs": [], + "outputs": [ + { + "name": "excludedContracts_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeSelectors", + "inputs": [], + "outputs": [ + { + "name": "excludedSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzSelector[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeSenders", + "inputs": [], + "outputs": [ + { + "name": "excludedSenders_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "failed", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "setUp", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "simulateForkAndTransfer", + "inputs": [ + { + "name": "forkAtBlock", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "sender", + "type": "address", + "internalType": "address" + }, + { + "name": "receiver", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "targetArtifactSelectors", + "inputs": [], + "outputs": [ + { + "name": "targetedArtifactSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzArtifactSelector[]", + "components": [ + { + "name": "artifact", + "type": "string", + "internalType": "string" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetArtifacts", + "inputs": [], + "outputs": [ + { + "name": "targetedArtifacts_", + "type": "string[]", + "internalType": "string[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetContracts", + "inputs": [], + "outputs": [ + { + "name": "targetedContracts_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetInterfaces", + "inputs": [], + "outputs": [ + { + "name": "targetedInterfaces_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzInterface[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "artifacts", + "type": "string[]", + "internalType": "string[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetSelectors", + "inputs": [], + "outputs": [ + { + "name": "targetedSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzSelector[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetSenders", + "inputs": [], + "outputs": [ + { + "name": "targetedSenders_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "testIonicStrategy", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "token", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IERC20" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "log", + "inputs": [ + { + "name": "", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_address", + "inputs": [ + { + "name": "", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "uint256[]", + "indexed": false, + "internalType": "uint256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "int256[]", + "indexed": false, + "internalType": "int256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "address[]", + "indexed": false, + "internalType": "address[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_bytes", + "inputs": [ + { + "name": "", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_bytes32", + "inputs": [ + { + "name": "", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_int", + "inputs": [ + { + "name": "", + "type": "int256", + "indexed": false, + "internalType": "int256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_address", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256[]", + "indexed": false, + "internalType": "uint256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256[]", + "indexed": false, + "internalType": "int256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "address[]", + "indexed": false, + "internalType": "address[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_bytes", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_bytes32", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_decimal_int", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256", + "indexed": false, + "internalType": "int256" + }, + { + "name": "decimals", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_decimal_uint", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "decimals", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_int", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256", + "indexed": false, + "internalType": "int256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_string", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_uint", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_string", + "inputs": [ + { + "name": "", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_uint", + "inputs": [ + { + "name": "", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "logs", + "inputs": [ + { + "name": "", + "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 IonicStrategyForked { + use super::*; + use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15`+W__\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16t\xBB\xA2\xEF\x94]R^<#\x11a\0\xCEW\x80c>^<#\x14a\x01DW\x80c?r\x86\xF4\x14a\x01LW\x80cf\xD9\xA9\xA0\x14a\x01TW\x80c\x85\"l\x81\x14a\x01iW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x1B\x8F\xFF@\x14a\x01\tW\x80c\x1E\xD7\x83\x1C\x14a\x01\x11W\x80c*\xDE8\x80\x14a\x01/W[__\xFD[a\x01\x07a\x02-V[\0[a\x01\x07a\x02nV[a\x01\x19a\x05\xE1V[`@Qa\x01&\x91\x90a\x11\xA3V[`@Q\x80\x91\x03\x90\xF3[a\x017a\x06NV[`@Qa\x01&\x91\x90a\x12)V[a\x01\x19a\x07\x97V[a\x01\x19a\x08\x02V[a\x01\\a\x08mV[`@Qa\x01&\x91\x90a\x13yV[a\x01qa\t\xE6V[`@Qa\x01&\x91\x90a\x13\xF7V[a\x01\x86a\n\xB1V[`@Qa\x01&\x91\x90a\x14NV[a\x01\x86a\x0B\xB4V[a\x01qa\x0C\xB7V[a\x01\xABa\r\x82V[`@Q\x90\x15\x15\x81R` \x01a\x01&V[a\x01\x19a\x0ERV[a\x01\x07a\x01\xD16`\x04a\x14\xFAV[a\x0E\xBDV[`\x1FTa\x01\xAB\x90`\xFF\x16\x81V[`\x1FTa\x02\x08\x90a\x01\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[`@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&V[a\x02lb\\\xBA\x95s\xA7\x9A5k\x01\xEF\x80[0\x89\xB4\xFEgD{\x96\xC7\xE6\xDDLs\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Eg\r\xE0\xB6\xB3\xA7d\0\0a\x0E\xBDV[V[`@Qsh\xE0\xE4\xD8u\xFD\xE3O\xC4i\x8F@\xCC\xCA\r\xB5\xB6~6\x93\x90s\x9C\xFE\xE8\x19p\xAA\x10\xCCY;\x83\xFB\x96\xEA\xA9\x88\nm\xF7\x15\x90_\x90\x83\x90\x83\x90a\x02\xAC\x90a\x11\x96V[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x02\xE9W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x03cW__\xFD[PZ\xF1\x15\x80\x15a\x03uW=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\xFCW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04 \x91\x90a\x15;V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xB8W__\xFD[PZ\xF1\x15\x80\x15a\x04\xCAW=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05'W__\xFD[PZ\xF1\x15\x80\x15a\x059W=__>=_\xFD[PP`@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\x81R`\x01`\x04\x82\x01Ra\x05\xDC\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xAAW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xCE\x91\x90a\x15aV[gEc\x91\x81\xFF1}ca\x11\x13V[PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06DW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x06\x19W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x07wW\x83\x82\x90_R` _ \x01\x80Ta\x06\xEC\x90a\x15xV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07\x18\x90a\x15xV[\x80\x15a\x07cW\x80`\x1F\x10a\x07:Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07cV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07FW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x06\xCFV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x06qV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06DW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x06\x19WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06DW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x06\x19WPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x08\xC0\x90a\x15xV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x08\xEC\x90a\x15xV[\x80\x15a\t7W\x80`\x1F\x10a\t\x0EWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\t7V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t\x1AW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\t\xCEW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\t{W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x08\x90V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW\x83\x82\x90_R` _ \x01\x80Ta\n&\x90a\x15xV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\nR\x90a\x15xV[\x80\x15a\n\x9DW\x80`\x1F\x10a\ntWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\x9DV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\n\x80W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\n\tV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0B\x9CW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0BIW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\n\xD4V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\x9FW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0CLW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0B\xD7V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW\x83\x82\x90_R` _ \x01\x80Ta\x0C\xF7\x90a\x15xV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r#\x90a\x15xV[\x80\x15a\rnW\x80`\x1F\x10a\rEWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rnV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\rQW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xDAV[`\x08T_\x90`\xFF\x16\x15a\r\x99WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E'W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0EK\x91\x90a\x15aV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06DW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x06\x19WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0FXW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x0F\x7F\x91\x90\x81\x01\x90a\x15\xF6V[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0F\x9D\x92\x91\x90a\x16\xAAV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0F\xB9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xDD\x91\x90a\x15aV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10VW__\xFD[PZ\xF1\x15\x80\x15a\x10hW=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10\xE8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\x0C\x91\x90a\x15;V[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x11|W__\xFD[PZ\xFA\x15\x80\x15a\x11\x8EW=__>=_\xFD[PPPPPPV[a\x11.\x80a\x16\xCC\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x11\xF0W\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\x11\xBCV[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x11W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x12\xF7W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x12\xE1\x84\x86Qa\x11\xFBV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x12\xA7V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x12OV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x13oW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x13/V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x11W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x13\xC5`@\x88\x01\x82a\x11\xFBV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x13\xE0\x81\x83a\x13\x1DV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x13\x9FV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x11W`?\x19\x87\x86\x03\x01\x84Ra\x149\x85\x83Qa\x11\xFBV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\x1DV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x11W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x14\xBC`@\x87\x01\x82a\x13\x1DV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14tV[\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\xF5W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x15\rW__\xFD[\x845\x93Pa\x15\x1D` \x86\x01a\x14\xD2V[\x92Pa\x15+`@\x86\x01a\x14\xD2V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[_` \x82\x84\x03\x12\x15a\x15KW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x15ZW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x15qW__\xFD[PQ\x91\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x15\x8CW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x15\xC3W\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[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\x16\x06W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\x1CW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x16,W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16FWa\x16Fa\x15\xC9V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x16vWa\x16va\x15\xC9V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x16\x8DW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x16\xBC`@\x83\x01\x85a\x11\xFBV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x11.8\x03\x80a\x11.\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x10Qa\0\xDD_9_\x81\x81`S\x01Ra\x02\xD1\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xBF\x01R\x81\x81a\x02S\x01R\x81\x81a\x03\xE8\x01Ra\x05\xD4\x01Ra\x10Q_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x16\xF0\x11[\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xF6s\xF0\xD9\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\x0C\xB1V[a\0\xEDV[\0[a\0\xB1a\0\xC16`\x04a\rsV[a\x01\x17V[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[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\r\xF7V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x07LV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x08\x10V[`@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\x83\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\x91_\x91\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0E\x1BV[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R\x91\x92P_\x91\x90` \x80\x83\x01\x90\x806\x837\x01\x90PP\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\x81_\x81Q\x81\x10a\x02\x84Wa\x02\x84a\x0E2V[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`@Q\x7F\xC2\x99\x828\0\0\0\0\0\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\x7F\0\0\0\0\0\0\0\0\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\xC2\x99\x828\x90a\x03\x06\x90\x85\x90`\x04\x01a\x0E_V[_`@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03!W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x03H\x91\x90\x81\x01\x90a\x0E\xB7V[\x90P\x80_\x81Q\x81\x10a\x03\\Wa\x03\\a\x0E2V[` \x02` \x01\x01Q_\x14a\x03\xB7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FCouldn't enter in Market\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@Q\x7F\xA0q-h\0\0\0\0\0\0\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\x88\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\xA0q-h\x90`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04g\x91\x90a\x0E\x1BV[\x90P\x80\x15a\x04\xDCW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FCould not mint token in Ionic ma`D\x82\x01R\x7Frket\0\0\0\0\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\x03\xAEV[`@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\x87\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05j\x91\x90a\x0E\x1BV[\x90Pa\x05\x8Ds\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x89\x83a\t\x0BV[`@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\x89\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\x1BW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06?\x91\x90a\x0E\x1BV[\x90P\x85\x81\x11a\x06\x90W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01a\x03\xAEV[_a\x06\x9B\x87\x83a\x0F\x85V[\x89Q\x90\x91P\x81\x10\x15a\x06\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xAEV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8A\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x08\n\x90\x85\x90\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\x90`\x84\x01[`@\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\tfV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x84W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\xA8\x91\x90a\x0E\x1BV[a\x08\xB2\x91\x90a\x0F\x9EV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x08\n\x90\x85\x90\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\x90`d\x01a\x07\xA6V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\ta\x90\x84\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\x90`d\x01a\x07\xA6V[PPPV[_a\t\xC7\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\nW\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\taW\x80\x80` \x01\x90Q\x81\x01\x90a\t\xE5\x91\x90a\x0F\xB1V[a\taW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xAEV[``a\ne\x84\x84_\x85a\noV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\n\xE7W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xAEV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x0BKW`@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\x03\xAEV[__\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\x0Bs\x91\x90a\x0F\xD0V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x0B\xADW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x0B\xB2V[``\x91P[P\x91P\x91Pa\x0B\xC2\x82\x82\x86a\x0B\xCDV[\x97\x96PPPPPPPV[``\x83\x15a\x0B\xDCWP\x81a\nhV[\x82Q\x15a\x0B\xECW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xAE\x91\x90a\x0F\xE6V[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\x0C'W__\xFD[PV[\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\x0CzWa\x0Cza\x0C*V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0C\xA9Wa\x0C\xA9a\x0C*V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0C\xC4W__\xFD[\x845a\x0C\xCF\x81a\x0C\x06V[\x93P` \x85\x015\x92P`@\x85\x015a\x0C\xE6\x81a\x0C\x06V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\x01W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\r\x11W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r+Wa\r+a\x0C*V[a\r>` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0C\x80V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\rRW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\r\x87W__\xFD[\x855a\r\x92\x81a\x0C\x06V[\x94P` \x86\x015\x93P`@\x86\x015a\r\xA9\x81a\x0C\x06V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\r\xDAW__\xFD[Pa\r\xE3a\x0CWV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0E\x08W__\xFD[Pa\x0E\x11a\x0CWV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0E+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[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x0E\xACW\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\x0ExV[P\x90\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x0E\xC7W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0E\xDDW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x0E\xEDW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0F\x07Wa\x0F\x07a\x0C*V[\x80`\x05\x1Ba\x0F\x17` \x82\x01a\x0C\x80V[\x91\x82R` \x81\x84\x01\x81\x01\x92\x90\x81\x01\x90\x87\x84\x11\x15a\x0F2W__\xFD[` \x85\x01\x94P[\x83\x85\x10\x15a\x0B\xC2W\x84Q\x80\x83R` \x95\x86\x01\x95\x90\x93P\x90\x91\x01\x90a\x0F9V[\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\x0F\x98Wa\x0F\x98a\x0FXV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0F\x98Wa\x0F\x98a\x0FXV[_` \x82\x84\x03\x12\x15a\x0F\xC1W__\xFD[\x81Q\x80\x15\x15\x81\x14a\nhW__\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\xFE\xA2dipfsX\"\x12 \xA63\xC5\xE5\xEB@\xCE\xD5\xA8\xAC\xC4\xC9\xF1HKy%\x82\xCD\xE3]\xB9\xCEE\xC8l\xF1O\x15\xEA\xD7\xF0dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 Cw\x8D\x87x\xB9]iA\xFE\x1EsL$\xDD\rW\x187\xCE\xEB\x0F).r\xFD~YSN\x9D\x1BdsolcC\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\0\xFBW_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\x93W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x01\xBBW\x80c\xF9\xCE\x0EZ\x14a\x01\xC3W\x80c\xFAv&\xD4\x14a\x01\xD6W\x80c\xFC\x0CTj\x14a\x01\xE3W__\xFD[\x80c\x91j\x17\xC6\x14a\x01~W\x80c\xB0FO\xDC\x14a\x01\x93W\x80c\xB5P\x8A\xA9\x14a\x01\x9BW\x80c\xBAAO\xA6\x14a\x01\xA3W__\xFD[\x80c>^<#\x11a\0\xCEW\x80c>^<#\x14a\x01DW\x80c?r\x86\xF4\x14a\x01LW\x80cf\xD9\xA9\xA0\x14a\x01TW\x80c\x85\"l\x81\x14a\x01iW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x1B\x8F\xFF@\x14a\x01\tW\x80c\x1E\xD7\x83\x1C\x14a\x01\x11W\x80c*\xDE8\x80\x14a\x01/W[__\xFD[a\x01\x07a\x02-V[\0[a\x01\x07a\x02nV[a\x01\x19a\x05\xE1V[`@Qa\x01&\x91\x90a\x11\xA3V[`@Q\x80\x91\x03\x90\xF3[a\x017a\x06NV[`@Qa\x01&\x91\x90a\x12)V[a\x01\x19a\x07\x97V[a\x01\x19a\x08\x02V[a\x01\\a\x08mV[`@Qa\x01&\x91\x90a\x13yV[a\x01qa\t\xE6V[`@Qa\x01&\x91\x90a\x13\xF7V[a\x01\x86a\n\xB1V[`@Qa\x01&\x91\x90a\x14NV[a\x01\x86a\x0B\xB4V[a\x01qa\x0C\xB7V[a\x01\xABa\r\x82V[`@Q\x90\x15\x15\x81R` \x01a\x01&V[a\x01\x19a\x0ERV[a\x01\x07a\x01\xD16`\x04a\x14\xFAV[a\x0E\xBDV[`\x1FTa\x01\xAB\x90`\xFF\x16\x81V[`\x1FTa\x02\x08\x90a\x01\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[`@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&V[a\x02lb\\\xBA\x95s\xA7\x9A5k\x01\xEF\x80[0\x89\xB4\xFEgD{\x96\xC7\xE6\xDDLs\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Eg\r\xE0\xB6\xB3\xA7d\0\0a\x0E\xBDV[V[`@Qsh\xE0\xE4\xD8u\xFD\xE3O\xC4i\x8F@\xCC\xCA\r\xB5\xB6~6\x93\x90s\x9C\xFE\xE8\x19p\xAA\x10\xCCY;\x83\xFB\x96\xEA\xA9\x88\nm\xF7\x15\x90_\x90\x83\x90\x83\x90a\x02\xAC\x90a\x11\x96V[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x02\xE9W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x03cW__\xFD[PZ\xF1\x15\x80\x15a\x03uW=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\xFCW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04 \x91\x90a\x15;V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xB8W__\xFD[PZ\xF1\x15\x80\x15a\x04\xCAW=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05'W__\xFD[PZ\xF1\x15\x80\x15a\x059W=__>=_\xFD[PP`@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\x81R`\x01`\x04\x82\x01Ra\x05\xDC\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xAAW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xCE\x91\x90a\x15aV[gEc\x91\x81\xFF1}ca\x11\x13V[PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06DW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x06\x19W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x07wW\x83\x82\x90_R` _ \x01\x80Ta\x06\xEC\x90a\x15xV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07\x18\x90a\x15xV[\x80\x15a\x07cW\x80`\x1F\x10a\x07:Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07cV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07FW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x06\xCFV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x06qV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06DW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x06\x19WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06DW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x06\x19WPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x08\xC0\x90a\x15xV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x08\xEC\x90a\x15xV[\x80\x15a\t7W\x80`\x1F\x10a\t\x0EWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\t7V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t\x1AW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\t\xCEW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\t{W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x08\x90V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW\x83\x82\x90_R` _ \x01\x80Ta\n&\x90a\x15xV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\nR\x90a\x15xV[\x80\x15a\n\x9DW\x80`\x1F\x10a\ntWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\x9DV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\n\x80W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\n\tV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0B\x9CW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0BIW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\n\xD4V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\x9FW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0CLW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0B\xD7V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW\x83\x82\x90_R` _ \x01\x80Ta\x0C\xF7\x90a\x15xV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r#\x90a\x15xV[\x80\x15a\rnW\x80`\x1F\x10a\rEWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rnV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\rQW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xDAV[`\x08T_\x90`\xFF\x16\x15a\r\x99WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E'W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0EK\x91\x90a\x15aV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06DW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x06\x19WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0FXW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x0F\x7F\x91\x90\x81\x01\x90a\x15\xF6V[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0F\x9D\x92\x91\x90a\x16\xAAV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0F\xB9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xDD\x91\x90a\x15aV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10VW__\xFD[PZ\xF1\x15\x80\x15a\x10hW=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10\xE8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\x0C\x91\x90a\x15;V[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x11|W__\xFD[PZ\xFA\x15\x80\x15a\x11\x8EW=__>=_\xFD[PPPPPPV[a\x11.\x80a\x16\xCC\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x11\xF0W\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\x11\xBCV[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x11W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x12\xF7W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x12\xE1\x84\x86Qa\x11\xFBV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x12\xA7V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x12OV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x13oW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x13/V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x11W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x13\xC5`@\x88\x01\x82a\x11\xFBV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x13\xE0\x81\x83a\x13\x1DV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x13\x9FV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x11W`?\x19\x87\x86\x03\x01\x84Ra\x149\x85\x83Qa\x11\xFBV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\x1DV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x11W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x14\xBC`@\x87\x01\x82a\x13\x1DV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14tV[\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\xF5W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x15\rW__\xFD[\x845\x93Pa\x15\x1D` \x86\x01a\x14\xD2V[\x92Pa\x15+`@\x86\x01a\x14\xD2V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[_` \x82\x84\x03\x12\x15a\x15KW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x15ZW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x15qW__\xFD[PQ\x91\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x15\x8CW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x15\xC3W\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[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\x16\x06W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\x1CW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x16,W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16FWa\x16Fa\x15\xC9V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x16vWa\x16va\x15\xC9V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x16\x8DW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x16\xBC`@\x83\x01\x85a\x11\xFBV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x11.8\x03\x80a\x11.\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x10Qa\0\xDD_9_\x81\x81`S\x01Ra\x02\xD1\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xBF\x01R\x81\x81a\x02S\x01R\x81\x81a\x03\xE8\x01Ra\x05\xD4\x01Ra\x10Q_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x16\xF0\x11[\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xF6s\xF0\xD9\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\x0C\xB1V[a\0\xEDV[\0[a\0\xB1a\0\xC16`\x04a\rsV[a\x01\x17V[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[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\r\xF7V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x07LV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x08\x10V[`@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\x83\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\x91_\x91\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0E\x1BV[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R\x91\x92P_\x91\x90` \x80\x83\x01\x90\x806\x837\x01\x90PP\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\x81_\x81Q\x81\x10a\x02\x84Wa\x02\x84a\x0E2V[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`@Q\x7F\xC2\x99\x828\0\0\0\0\0\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\x7F\0\0\0\0\0\0\0\0\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\xC2\x99\x828\x90a\x03\x06\x90\x85\x90`\x04\x01a\x0E_V[_`@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03!W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x03H\x91\x90\x81\x01\x90a\x0E\xB7V[\x90P\x80_\x81Q\x81\x10a\x03\\Wa\x03\\a\x0E2V[` \x02` \x01\x01Q_\x14a\x03\xB7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FCouldn't enter in Market\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@Q\x7F\xA0q-h\0\0\0\0\0\0\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\x88\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\xA0q-h\x90`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04g\x91\x90a\x0E\x1BV[\x90P\x80\x15a\x04\xDCW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FCould not mint token in Ionic ma`D\x82\x01R\x7Frket\0\0\0\0\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\x03\xAEV[`@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\x87\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05j\x91\x90a\x0E\x1BV[\x90Pa\x05\x8Ds\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x89\x83a\t\x0BV[`@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\x89\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\x1BW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06?\x91\x90a\x0E\x1BV[\x90P\x85\x81\x11a\x06\x90W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01a\x03\xAEV[_a\x06\x9B\x87\x83a\x0F\x85V[\x89Q\x90\x91P\x81\x10\x15a\x06\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xAEV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8A\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x08\n\x90\x85\x90\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\x90`\x84\x01[`@\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\tfV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x84W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\xA8\x91\x90a\x0E\x1BV[a\x08\xB2\x91\x90a\x0F\x9EV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x08\n\x90\x85\x90\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\x90`d\x01a\x07\xA6V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\ta\x90\x84\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\x90`d\x01a\x07\xA6V[PPPV[_a\t\xC7\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\nW\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\taW\x80\x80` \x01\x90Q\x81\x01\x90a\t\xE5\x91\x90a\x0F\xB1V[a\taW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xAEV[``a\ne\x84\x84_\x85a\noV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\n\xE7W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xAEV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x0BKW`@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\x03\xAEV[__\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\x0Bs\x91\x90a\x0F\xD0V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x0B\xADW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x0B\xB2V[``\x91P[P\x91P\x91Pa\x0B\xC2\x82\x82\x86a\x0B\xCDV[\x97\x96PPPPPPPV[``\x83\x15a\x0B\xDCWP\x81a\nhV[\x82Q\x15a\x0B\xECW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xAE\x91\x90a\x0F\xE6V[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\x0C'W__\xFD[PV[\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\x0CzWa\x0Cza\x0C*V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0C\xA9Wa\x0C\xA9a\x0C*V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0C\xC4W__\xFD[\x845a\x0C\xCF\x81a\x0C\x06V[\x93P` \x85\x015\x92P`@\x85\x015a\x0C\xE6\x81a\x0C\x06V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\x01W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\r\x11W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r+Wa\r+a\x0C*V[a\r>` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0C\x80V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\rRW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\r\x87W__\xFD[\x855a\r\x92\x81a\x0C\x06V[\x94P` \x86\x015\x93P`@\x86\x015a\r\xA9\x81a\x0C\x06V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\r\xDAW__\xFD[Pa\r\xE3a\x0CWV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0E\x08W__\xFD[Pa\x0E\x11a\x0CWV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0E+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[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x0E\xACW\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\x0ExV[P\x90\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x0E\xC7W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0E\xDDW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x0E\xEDW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0F\x07Wa\x0F\x07a\x0C*V[\x80`\x05\x1Ba\x0F\x17` \x82\x01a\x0C\x80V[\x91\x82R` \x81\x84\x01\x81\x01\x92\x90\x81\x01\x90\x87\x84\x11\x15a\x0F2W__\xFD[` \x85\x01\x94P[\x83\x85\x10\x15a\x0B\xC2W\x84Q\x80\x83R` \x95\x86\x01\x95\x90\x93P\x90\x91\x01\x90a\x0F9V[\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\x0F\x98Wa\x0F\x98a\x0FXV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0F\x98Wa\x0F\x98a\x0FXV[_` \x82\x84\x03\x12\x15a\x0F\xC1W__\xFD[\x81Q\x80\x15\x15\x81\x14a\nhW__\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\xFE\xA2dipfsX\"\x12 \xA63\xC5\xE5\xEB@\xCE\xD5\xA8\xAC\xC4\xC9\xF1HKy%\x82\xCD\xE3]\xB9\xCEE\xC8l\xF1O\x15\xEA\xD7\xF0dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 Cw\x8D\x87x\xB9]iA\xFE\x1EsL$\xDD\rW\x187\xCE\xEB\x0F).r\xFD~YSN\x9D\x1BdsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. +```solidity +event log(string); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log { + type DataTuple<'a> = (alloy::sol_types::sol_data::String,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log(string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, + 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, + 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. +```solidity +event log_address(address); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_address { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_address { + type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_address(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, + 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, + 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_address { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_address> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_address) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. +```solidity +event log_array(uint256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_0 { + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_0 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(uint256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, + 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, + 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_0 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_0> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. +```solidity +event log_array(int256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_1 { + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_1 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(int256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, + 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, + 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_1 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_1> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. +```solidity +event log_array(address[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_2 { + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_2 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(address[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, + 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, + 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_2 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_2> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. +```solidity +event log_bytes(bytes); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_bytes { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_bytes { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_bytes(bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, + 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, + 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_bytes { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_bytes> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. +```solidity +event log_bytes32(bytes32); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_bytes32 { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_bytes32 { + type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_bytes32(bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, + 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, + 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_bytes32 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_bytes32> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. +```solidity +event log_int(int256); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_int { + #[allow(missing_docs)] + pub _0: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_int { + type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_int(int256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, + 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, + 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. +```solidity +event log_named_address(string key, address val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_address { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_address { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Address, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_address(string,address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, + 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, + 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_address { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_address> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. +```solidity +event log_named_array(string key, uint256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_0 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_0 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, + 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, + 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_0 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_0> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. +```solidity +event log_named_array(string key, int256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_1 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_1 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,int256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, + 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, + 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_1 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_1> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. +```solidity +event log_named_array(string key, address[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_2 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_2 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,address[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, + 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, + 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_2 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_2> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. +```solidity +event log_named_bytes(string key, bytes val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_bytes { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_bytes { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Bytes, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, + 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, + 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_bytes { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_bytes> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. +```solidity +event log_named_bytes32(string key, bytes32 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_bytes32 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_bytes32 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::FixedBytes<32>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, + 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, + 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_bytes32 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. +```solidity +event log_named_decimal_int(string key, int256 val, uint256 decimals); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_decimal_int { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::I256, + #[allow(missing_docs)] + pub decimals: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_decimal_int { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Int<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, + 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, + 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + key: data.0, + val: data.1, + decimals: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + as alloy_sol_types::SolType>::tokenize(&self.decimals), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_decimal_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. +```solidity +event log_named_decimal_uint(string key, uint256 val, uint256 decimals); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_decimal_uint { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub decimals: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_decimal_uint { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, + 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, + 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + key: data.0, + val: data.1, + decimals: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + as alloy_sol_types::SolType>::tokenize(&self.decimals), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. +```solidity +event log_named_int(string key, int256 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_int { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_int { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Int<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_int(string,int256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, + 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, + 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. +```solidity +event log_named_string(string key, string val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_string { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::String, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_string { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::String, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_string(string,string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, + 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, + 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_string { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_string> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. +```solidity +event log_named_uint(string key, uint256 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_uint { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_uint { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, + 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, + 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. +```solidity +event log_string(string); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_string { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_string { + type DataTuple<'a> = (alloy::sol_types::sol_data::String,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_string(string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, + 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, + 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_string { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_string> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_string) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. +```solidity +event log_uint(uint256); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_uint { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_uint { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_uint(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, + 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, + 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. +```solidity +event logs(bytes); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct logs { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for logs { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "logs(bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, + 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, + 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 logs { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&logs> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &logs) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. +```solidity +function IS_TEST() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IS_TESTCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IS_TESTReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IS_TESTCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IS_TESTCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IS_TESTReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IS_TESTReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for IS_TESTCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "IS_TEST()"; + const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: IS_TESTReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: IS_TESTReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. +```solidity +function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeArtifactsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeArtifactsReturn { + #[allow(missing_docs)] + pub excludedArtifacts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeArtifactsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeArtifactsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeArtifactsReturn) -> Self { + (value.excludedArtifacts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeArtifactsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedArtifacts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeArtifactsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeArtifacts()"; + const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeArtifactsReturn = r.into(); + r.excludedArtifacts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeArtifactsReturn = r.into(); + r.excludedArtifacts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. +```solidity +function excludeContracts() external view returns (address[] memory excludedContracts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeContractsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeContractsReturn { + #[allow(missing_docs)] + pub excludedContracts_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeContractsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeContractsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeContractsReturn) -> Self { + (value.excludedContracts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeContractsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedContracts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeContractsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeContracts()"; + const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeContractsReturn = r.into(); + r.excludedContracts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeContractsReturn = r.into(); + r.excludedContracts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. +```solidity +function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSelectorsReturn { + #[allow(missing_docs)] + pub excludedSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSelectorsReturn) -> Self { + (value.excludedSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeSelectors()"; + const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeSelectorsReturn = r.into(); + r.excludedSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeSelectorsReturn = r.into(); + r.excludedSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. +```solidity +function excludeSenders() external view returns (address[] memory excludedSenders_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSendersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSendersReturn { + #[allow(missing_docs)] + pub excludedSenders_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: excludeSendersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for excludeSendersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSendersReturn) -> Self { + (value.excludedSenders_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSendersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { excludedSenders_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeSendersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeSenders()"; + const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeSendersReturn = r.into(); + r.excludedSenders_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeSendersReturn = r.into(); + r.excludedSenders_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `failed()` and selector `0xba414fa6`. +```solidity +function failed() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct failedCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`failed()`](failedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct failedReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: failedCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for failedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: failedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for failedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for failedCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "failed()"; + const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: failedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: failedReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `setUp()` and selector `0x0a9254e4`. +```solidity +function setUp() external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setUpCall; + ///Container type for the return parameters of the [`setUp()`](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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setUpCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setUpReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setUpReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setUpCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setUpReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setUp()"; + const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setUpReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. +```solidity +function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct simulateForkAndTransferCall { + #[allow(missing_docs)] + pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub sender: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct simulateForkAndTransferReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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::Uint<256>, + ); + #[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::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferCall) -> Self { + (value.forkAtBlock, value.sender, value.receiver, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for simulateForkAndTransferCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + forkAtBlock: tuple.0, + sender: tuple.1, + receiver: tuple.2, + amount: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for simulateForkAndTransferReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl simulateForkAndTransferReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for simulateForkAndTransferCall { + type Parameters<'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::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = simulateForkAndTransferReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; + const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), + ::tokenize( + &self.sender, + ), + ::tokenize( + &self.receiver, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + simulateForkAndTransferReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. +```solidity +function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactSelectorsReturn { + #[allow(missing_docs)] + pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactSelectorsReturn) -> Self { + (value.targetedArtifactSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedArtifactSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetArtifactSelectors()"; + const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetArtifacts()` and selector `0x85226c81`. +```solidity +function targetArtifacts() external view returns (string[] memory targetedArtifacts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactsReturn { + #[allow(missing_docs)] + pub targetedArtifacts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetArtifactsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsReturn) -> Self { + (value.targetedArtifacts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedArtifacts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetArtifactsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetArtifacts()"; + const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetContracts()` and selector `0x3f7286f4`. +```solidity +function targetContracts() external view returns (address[] memory targetedContracts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetContractsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetContractsReturn { + #[allow(missing_docs)] + pub targetedContracts_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetContractsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetContractsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetContractsReturn) -> Self { + (value.targetedContracts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetContractsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedContracts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetContractsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetContracts()"; + const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetContractsReturn = r.into(); + r.targetedContracts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetContractsReturn = r.into(); + r.targetedContracts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. +```solidity +function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetInterfacesCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetInterfacesReturn { + #[allow(missing_docs)] + pub targetedInterfaces_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetInterfacesCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetInterfacesCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetInterfacesReturn) -> Self { + (value.targetedInterfaces_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetInterfacesReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedInterfaces_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetInterfacesCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetInterfaces()"; + const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetSelectors()` and selector `0x916a17c6`. +```solidity +function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSelectorsReturn { + #[allow(missing_docs)] + pub targetedSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetSelectorsReturn) -> Self { + (value.targetedSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetSelectors()"; + const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. +```solidity +function targetSenders() external view returns (address[] memory targetedSenders_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSendersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSendersReturn { + #[allow(missing_docs)] + pub targetedSenders_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSendersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersReturn) -> Self { + (value.targetedSenders_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSendersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { targetedSenders_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetSendersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetSenders()"; + const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetSendersReturn = r.into(); + r.targetedSenders_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetSendersReturn = r.into(); + r.targetedSenders_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `testIonicStrategy()` and selector `0x1b8fff40`. +```solidity +function testIonicStrategy() external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct testIonicStrategyCall; + ///Container type for the return parameters of the [`testIonicStrategy()`](testIonicStrategyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct testIonicStrategyReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: testIonicStrategyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for testIonicStrategyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: testIonicStrategyReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for testIonicStrategyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl testIonicStrategyReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for testIonicStrategyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = testIonicStrategyReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "testIonicStrategy()"; + const SELECTOR: [u8; 4] = [27u8, 143u8, 255u8, 64u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + testIonicStrategyReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `token()` and selector `0xfc0c546a`. +```solidity +function token() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct tokenCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`token()`](tokenCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct tokenReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for tokenCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for tokenReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for tokenCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "token()"; + const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`IonicStrategyForked`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum IonicStrategyForkedCalls { + #[allow(missing_docs)] + IS_TEST(IS_TESTCall), + #[allow(missing_docs)] + excludeArtifacts(excludeArtifactsCall), + #[allow(missing_docs)] + excludeContracts(excludeContractsCall), + #[allow(missing_docs)] + excludeSelectors(excludeSelectorsCall), + #[allow(missing_docs)] + excludeSenders(excludeSendersCall), + #[allow(missing_docs)] + failed(failedCall), + #[allow(missing_docs)] + setUp(setUpCall), + #[allow(missing_docs)] + simulateForkAndTransfer(simulateForkAndTransferCall), + #[allow(missing_docs)] + targetArtifactSelectors(targetArtifactSelectorsCall), + #[allow(missing_docs)] + targetArtifacts(targetArtifactsCall), + #[allow(missing_docs)] + targetContracts(targetContractsCall), + #[allow(missing_docs)] + targetInterfaces(targetInterfacesCall), + #[allow(missing_docs)] + targetSelectors(targetSelectorsCall), + #[allow(missing_docs)] + targetSenders(targetSendersCall), + #[allow(missing_docs)] + testIonicStrategy(testIonicStrategyCall), + #[allow(missing_docs)] + token(tokenCall), + } + #[automatically_derived] + impl IonicStrategyForkedCalls { + /// 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]] = &[ + [10u8, 146u8, 84u8, 228u8], + [27u8, 143u8, 255u8, 64u8], + [30u8, 215u8, 131u8, 28u8], + [42u8, 222u8, 56u8, 128u8], + [62u8, 94u8, 60u8, 35u8], + [63u8, 114u8, 134u8, 244u8], + [102u8, 217u8, 169u8, 160u8], + [133u8, 34u8, 108u8, 129u8], + [145u8, 106u8, 23u8, 198u8], + [176u8, 70u8, 79u8, 220u8], + [181u8, 80u8, 138u8, 169u8], + [186u8, 65u8, 79u8, 166u8], + [226u8, 12u8, 159u8, 113u8], + [249u8, 206u8, 14u8, 90u8], + [250u8, 118u8, 38u8, 212u8], + [252u8, 12u8, 84u8, 106u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for IonicStrategyForkedCalls { + const NAME: &'static str = "IonicStrategyForkedCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 16usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::IS_TEST(_) => ::SELECTOR, + Self::excludeArtifacts(_) => { + ::SELECTOR + } + Self::excludeContracts(_) => { + ::SELECTOR + } + Self::excludeSelectors(_) => { + ::SELECTOR + } + Self::excludeSenders(_) => { + ::SELECTOR + } + Self::failed(_) => ::SELECTOR, + Self::setUp(_) => ::SELECTOR, + Self::simulateForkAndTransfer(_) => { + ::SELECTOR + } + Self::targetArtifactSelectors(_) => { + ::SELECTOR + } + Self::targetArtifacts(_) => { + ::SELECTOR + } + Self::targetContracts(_) => { + ::SELECTOR + } + Self::targetInterfaces(_) => { + ::SELECTOR + } + Self::targetSelectors(_) => { + ::SELECTOR + } + Self::targetSenders(_) => { + ::SELECTOR + } + Self::testIonicStrategy(_) => { + ::SELECTOR + } + Self::token(_) => ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn setUp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IonicStrategyForkedCalls::setUp) + } + setUp + }, + { + fn testIonicStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IonicStrategyForkedCalls::testIonicStrategy) + } + testIonicStrategy + }, + { + fn excludeSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IonicStrategyForkedCalls::excludeSenders) + } + excludeSenders + }, + { + fn targetInterfaces( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IonicStrategyForkedCalls::targetInterfaces) + } + targetInterfaces + }, + { + fn targetSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IonicStrategyForkedCalls::targetSenders) + } + targetSenders + }, + { + fn targetContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IonicStrategyForkedCalls::targetContracts) + } + targetContracts + }, + { + fn targetArtifactSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IonicStrategyForkedCalls::targetArtifactSelectors) + } + targetArtifactSelectors + }, + { + fn targetArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IonicStrategyForkedCalls::targetArtifacts) + } + targetArtifacts + }, + { + fn targetSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IonicStrategyForkedCalls::targetSelectors) + } + targetSelectors + }, + { + fn excludeSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IonicStrategyForkedCalls::excludeSelectors) + } + excludeSelectors + }, + { + fn excludeArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IonicStrategyForkedCalls::excludeArtifacts) + } + excludeArtifacts + }, + { + fn failed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IonicStrategyForkedCalls::failed) + } + failed + }, + { + fn excludeContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IonicStrategyForkedCalls::excludeContracts) + } + excludeContracts + }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(IonicStrategyForkedCalls::simulateForkAndTransfer) + } + simulateForkAndTransfer + }, + { + fn IS_TEST( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IonicStrategyForkedCalls::IS_TEST) + } + IS_TEST + }, + { + fn token( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(IonicStrategyForkedCalls::token) + } + token + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn setUp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IonicStrategyForkedCalls::setUp) + } + setUp + }, + { + fn testIonicStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IonicStrategyForkedCalls::testIonicStrategy) + } + testIonicStrategy + }, + { + fn excludeSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IonicStrategyForkedCalls::excludeSenders) + } + excludeSenders + }, + { + fn targetInterfaces( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IonicStrategyForkedCalls::targetInterfaces) + } + targetInterfaces + }, + { + fn targetSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IonicStrategyForkedCalls::targetSenders) + } + targetSenders + }, + { + fn targetContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IonicStrategyForkedCalls::targetContracts) + } + targetContracts + }, + { + fn targetArtifactSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IonicStrategyForkedCalls::targetArtifactSelectors) + } + targetArtifactSelectors + }, + { + fn targetArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IonicStrategyForkedCalls::targetArtifacts) + } + targetArtifacts + }, + { + fn targetSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IonicStrategyForkedCalls::targetSelectors) + } + targetSelectors + }, + { + fn excludeSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IonicStrategyForkedCalls::excludeSelectors) + } + excludeSelectors + }, + { + fn excludeArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IonicStrategyForkedCalls::excludeArtifacts) + } + excludeArtifacts + }, + { + fn failed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IonicStrategyForkedCalls::failed) + } + failed + }, + { + fn excludeContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IonicStrategyForkedCalls::excludeContracts) + } + excludeContracts + }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IonicStrategyForkedCalls::simulateForkAndTransfer) + } + simulateForkAndTransfer + }, + { + fn IS_TEST( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IonicStrategyForkedCalls::IS_TEST) + } + IS_TEST + }, + { + fn token( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(IonicStrategyForkedCalls::token) + } + token + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::IS_TEST(inner) => { + ::abi_encoded_size(inner) + } + Self::excludeArtifacts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeContracts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeSenders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::failed(inner) => { + ::abi_encoded_size(inner) + } + Self::setUp(inner) => { + ::abi_encoded_size(inner) + } + Self::simulateForkAndTransfer(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetArtifactSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetArtifacts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetContracts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetInterfaces(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetSenders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::testIonicStrategy(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::token(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::IS_TEST(inner) => { + ::abi_encode_raw(inner, out) + } + Self::excludeArtifacts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeContracts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeSenders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::failed(inner) => { + ::abi_encode_raw(inner, out) + } + Self::setUp(inner) => { + ::abi_encode_raw(inner, out) + } + Self::simulateForkAndTransfer(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetArtifactSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetArtifacts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetContracts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetInterfaces(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetSenders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::testIonicStrategy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::token(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + ///Container for all the [`IonicStrategyForked`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum IonicStrategyForkedEvents { + #[allow(missing_docs)] + log(log), + #[allow(missing_docs)] + log_address(log_address), + #[allow(missing_docs)] + log_array_0(log_array_0), + #[allow(missing_docs)] + log_array_1(log_array_1), + #[allow(missing_docs)] + log_array_2(log_array_2), + #[allow(missing_docs)] + log_bytes(log_bytes), + #[allow(missing_docs)] + log_bytes32(log_bytes32), + #[allow(missing_docs)] + log_int(log_int), + #[allow(missing_docs)] + log_named_address(log_named_address), + #[allow(missing_docs)] + log_named_array_0(log_named_array_0), + #[allow(missing_docs)] + log_named_array_1(log_named_array_1), + #[allow(missing_docs)] + log_named_array_2(log_named_array_2), + #[allow(missing_docs)] + log_named_bytes(log_named_bytes), + #[allow(missing_docs)] + log_named_bytes32(log_named_bytes32), + #[allow(missing_docs)] + log_named_decimal_int(log_named_decimal_int), + #[allow(missing_docs)] + log_named_decimal_uint(log_named_decimal_uint), + #[allow(missing_docs)] + log_named_int(log_named_int), + #[allow(missing_docs)] + log_named_string(log_named_string), + #[allow(missing_docs)] + log_named_uint(log_named_uint), + #[allow(missing_docs)] + log_string(log_string), + #[allow(missing_docs)] + log_uint(log_uint), + #[allow(missing_docs)] + logs(logs), + } + #[automatically_derived] + impl IonicStrategyForkedEvents { + /// 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]] = &[ + [ + 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, + 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, + 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, + ], + [ + 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, + 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, + 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, + ], + [ + 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, + 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, + 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, + ], + [ + 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, + 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, + 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, + ], + [ + 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, + 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, + 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, + ], + [ + 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, + 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, + 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, + ], + [ + 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, + 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, + 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, + ], + [ + 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, + 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, + 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, + ], + [ + 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, + 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, + 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, + ], + [ + 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, + 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, + 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, + ], + [ + 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, + 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, + 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, + ], + [ + 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, + 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, + 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, + ], + [ + 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, + 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, + 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, + ], + [ + 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, + 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, + 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, + ], + [ + 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, + 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, + 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, + ], + [ + 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, + 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, + 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, + ], + [ + 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, + 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, + 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, + ], + [ + 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, + 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, + 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, + ], + [ + 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, + 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, + 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, + ], + [ + 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, + 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, + 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, + ], + [ + 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, + 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, + 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, + ], + [ + 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, + 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, + 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for IonicStrategyForkedEvents { + const NAME: &'static str = "IonicStrategyForkedEvents"; + const COUNT: usize = 22usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_address) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_0) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_1) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_2) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_bytes) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_bytes32) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log_int) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_address) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_0) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_1) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_2) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_bytes) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_bytes32) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_decimal_int) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_decimal_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_int) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_string) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_string) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::logs) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 IonicStrategyForkedEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::log(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_address(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_0(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_1(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_2(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_bytes(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_address(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_0(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_1(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_2(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_bytes(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_decimal_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_decimal_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_string(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_string(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::logs(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::log(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_address(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_0(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_1(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_2(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_bytes(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_address(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_0(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_1(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_2(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_bytes(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_decimal_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_decimal_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_string(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_string(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::logs(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`IonicStrategyForked`](self) contract instance. + +See the [wrapper's documentation](`IonicStrategyForkedInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> IonicStrategyForkedInstance { + IonicStrategyForkedInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + IonicStrategyForkedInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + IonicStrategyForkedInstance::::deploy_builder(provider) + } + /**A [`IonicStrategyForked`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`IonicStrategyForked`](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 IonicStrategyForkedInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for IonicStrategyForkedInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("IonicStrategyForkedInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IonicStrategyForkedInstance { + /**Creates a new wrapper around an on-chain [`IonicStrategyForked`](self) contract instance. + +See the [wrapper's documentation](`IonicStrategyForkedInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 IonicStrategyForkedInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> IonicStrategyForkedInstance { + IonicStrategyForkedInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IonicStrategyForkedInstance { + /// 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( + &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 [`IS_TEST`] function. + pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { + self.call_builder(&IS_TESTCall) + } + ///Creates a new call builder for the [`excludeArtifacts`] function. + pub fn excludeArtifacts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { + self.call_builder(&excludeArtifactsCall) + } + ///Creates a new call builder for the [`excludeContracts`] function. + pub fn excludeContracts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { + self.call_builder(&excludeContractsCall) + } + ///Creates a new call builder for the [`excludeSelectors`] function. + pub fn excludeSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { + self.call_builder(&excludeSelectorsCall) + } + ///Creates a new call builder for the [`excludeSenders`] function. + pub fn excludeSenders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { + self.call_builder(&excludeSendersCall) + } + ///Creates a new call builder for the [`failed`] function. + pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { + self.call_builder(&failedCall) + } + ///Creates a new call builder for the [`setUp`] function. + pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { + self.call_builder(&setUpCall) + } + ///Creates a new call builder for the [`simulateForkAndTransfer`] function. + pub fn simulateForkAndTransfer( + &self, + forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + sender: alloy::sol_types::private::Address, + receiver: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { + self.call_builder( + &simulateForkAndTransferCall { + forkAtBlock, + sender, + receiver, + amount, + }, + ) + } + ///Creates a new call builder for the [`targetArtifactSelectors`] function. + pub fn targetArtifactSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { + self.call_builder(&targetArtifactSelectorsCall) + } + ///Creates a new call builder for the [`targetArtifacts`] function. + pub fn targetArtifacts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { + self.call_builder(&targetArtifactsCall) + } + ///Creates a new call builder for the [`targetContracts`] function. + pub fn targetContracts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { + self.call_builder(&targetContractsCall) + } + ///Creates a new call builder for the [`targetInterfaces`] function. + pub fn targetInterfaces( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { + self.call_builder(&targetInterfacesCall) + } + ///Creates a new call builder for the [`targetSelectors`] function. + pub fn targetSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { + self.call_builder(&targetSelectorsCall) + } + ///Creates a new call builder for the [`targetSenders`] function. + pub fn targetSenders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { + self.call_builder(&targetSendersCall) + } + ///Creates a new call builder for the [`testIonicStrategy`] function. + pub fn testIonicStrategy( + &self, + ) -> alloy_contract::SolCallBuilder<&P, testIonicStrategyCall, N> { + self.call_builder(&testIonicStrategyCall) + } + ///Creates a new call builder for the [`token`] function. + pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { + self.call_builder(&tokenCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IonicStrategyForkedInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`log`] event. + pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_address`] event. + pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_0`] event. + pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_1`] event. + pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_2`] event. + pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_bytes`] event. + pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_bytes32`] event. + pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_int`] event. + pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_address`] event. + pub fn log_named_address_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_address, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_0`] event. + pub fn log_named_array_0_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_0, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_1`] event. + pub fn log_named_array_1_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_1, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_2`] event. + pub fn log_named_array_2_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_2, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_bytes`] event. + pub fn log_named_bytes_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_bytes, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_bytes32`] event. + pub fn log_named_bytes32_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_bytes32, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_decimal_int`] event. + pub fn log_named_decimal_int_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_decimal_uint`] event. + pub fn log_named_decimal_uint_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_int`] event. + pub fn log_named_int_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_string`] event. + pub fn log_named_string_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_string, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_uint`] event. + pub fn log_named_uint_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_string`] event. + pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_uint`] event. + pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`logs`] event. + pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/lib.rs b/crates/bindings/src/lib.rs index 73f9bedcf..02b886c2c 100644 --- a/crates/bindings/src/lib.rs +++ b/crates/bindings/src/lib.rs @@ -3,22 +3,85 @@ //! This is autogenerated code. //! Do not manually edit these files. //! These files may be overwritten by the codegen system at any time. -pub mod r#fullrelay; -pub mod r#fullrelayaddheadertest; -pub mod r#fullrelayaddheaderwithretargettest; -pub mod r#fullrelayconstructiontest; -pub mod r#fullrelayfindancestortest; -pub mod r#fullrelayfindheighttest; -pub mod r#fullrelayheaviestfromancestortest; -pub mod r#fullrelayheaviestfromancestorwithretargettest; -pub mod r#fullrelayisancestortest; -pub mod r#fullrelayismostancestortest; -pub mod r#fullrelaymarkheaviesttest; -pub mod r#fullrelaytestutils; -pub mod r#fullrelaywithverify; -pub mod r#fullrelaywithverifydirecttest; -pub mod r#fullrelaywithverifytest; -pub mod r#fullrelaywithverifythroughbitcointxtest; -pub mod r#fullrelaywithverifythroughwitnesstxtest; -pub mod r#ifullrelay; -pub mod r#ifullrelaywithverify; +pub mod r#address; +pub mod r#avalon_lending_strategy; +pub mod r#avalon_lst_strategy; +pub mod r#dummy_avalon_pool_implementation; +pub mod r#i_avalon_i_pool; +pub mod r#avalon_tbtc_lending_strategy_forked; +pub mod r#avalon_wbtc_lending_strategy_forked; +pub mod r#avalon_wbtc_lst_strategy_forked; +pub mod r#btc_utils; +pub mod r#bedrock_strategy; +pub mod r#dummy_bedrock_vault_implementation; +pub mod r#i_bedrock_vault; +pub mod r#bedrock_strategy_forked; +pub mod r#bitcoin_tx; +pub mod r#btc_market_place; +pub mod r#arbitary_erc20; +pub mod r#bytes_lib; +pub mod r#constants; +pub mod r#context; +pub mod r#erc20; +pub mod r#erc2771_recipient; +pub mod r#forked_strategy_template_tbtc; +pub mod r#forked_strategy_template_wbtc; +pub mod r#full_relay; +pub mod r#full_relay_with_verify; +pub mod r#hybrid_btc_strategy; +pub mod r#i_teller; +pub mod r#hybrid_btc_strategy_forked_wbtc; +pub mod r#ierc20; +pub mod r#ierc20_metadata; +pub mod r#ierc2771_recipient; +pub mod r#i_full_relay; +pub mod r#i_full_relay_with_verify; +pub mod r#i_light_relay; +pub mod r#i_strategy; +pub mod r#i_strategy_with_slippage_args; +pub mod r#dummy_ionic_pool; +pub mod r#dummy_ionic_token; +pub mod r#i_ionic_token; +pub mod r#i_pool; +pub mod r#ionic_strategy; +pub mod r#ionic_strategy_forked; +pub mod r#light_relay; +pub mod r#relay_utils; +pub mod r#market_place; +pub mod r#ord_marketplace; +pub mod r#ownable; +pub mod r#dummy_pell_strategy; +pub mod r#dummy_pell_strategy_manager; +pub mod r#i_pell_strategy; +pub mod r#i_pell_strategy_manager; +pub mod r#pell_bedrock_strategy; +pub mod r#pell_solv_lst_strategy; +pub mod r#pell_strategy; +pub mod r#pell_bed_rock_lst_strategy_forked; +pub mod r#pell_bed_rock_strategy_forked; +pub mod r#pell_strategy_forked; +pub mod r#safe_erc20; +pub mod r#safe_math; +pub mod r#seg_wit_utils; +pub mod r#dummy_se_bep20; +pub mod r#i_se_bep20; +pub mod r#segment_bedrock_strategy; +pub mod r#segment_solv_lst_strategy; +pub mod r#segment_strategy; +pub mod r#segment_bedrock_and_lst_strategy_forked; +pub mod r#segment_strategy_forked; +pub mod r#dummy_shoe_bill_token; +pub mod r#ic_erc20; +pub mod r#shoebill_strategy; +pub mod r#shoebill_tbtc_strategy_forked; +pub mod r#dummy_solv_router; +pub mod r#i_solv_btc_router; +pub mod r#solv_btc_strategy; +pub mod r#solv_lst_strategy; +pub mod r#solv_strategy_forked; +pub mod r#std_constants; +pub mod r#strings; +pub mod r#bitcoin_tx_builder; +pub mod r#utilities; +pub mod r#validate_spv; +pub mod r#witness_tx; diff --git a/crates/bindings/src/light_relay.rs b/crates/bindings/src/light_relay.rs new file mode 100644 index 000000000..324658ab2 --- /dev/null +++ b/crates/bindings/src/light_relay.rs @@ -0,0 +1,6027 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface LightRelay { + event AuthorizationRequirementChanged(bool newStatus); + event Genesis(uint256 blockHeight); + event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); + event ProofLengthChanged(uint256 newLength); + event Retarget(uint256 oldDifficulty, uint256 newDifficulty); + event SubmitterAuthorized(address submitter); + event SubmitterDeauthorized(address submitter); + + function authorizationRequired() external view returns (bool); + function authorize(address submitter) external; + function currentEpoch() external view returns (uint64); + function deauthorize(address submitter) external; + function genesis(bytes memory genesisHeader, uint256 genesisHeight, uint64 genesisProofLength) external; + function genesisEpoch() external view returns (uint64); + function getBlockDifficulty(uint256 blockNumber) external view returns (uint256); + function getCurrentAndPrevEpochDifficulty() external view returns (uint256 current, uint256 previous); + function getCurrentEpochDifficulty() external view returns (uint256); + function getEpochDifficulty(uint256 epochNumber) external view returns (uint256); + function getPrevEpochDifficulty() external view returns (uint256); + function getRelayRange() external view returns (uint256 relayGenesis, uint256 currentEpochEnd); + function isAuthorized(address) external view returns (bool); + function owner() external view returns (address); + function proofLength() external view returns (uint64); + function ready() external view returns (bool); + function renounceOwnership() external; + function retarget(bytes memory headers) external; + function setAuthorizationStatus(bool status) external; + function setProofLength(uint64 newLength) external; + function transferOwnership(address newOwner) external; + function validateChain(bytes memory headers) external view returns (uint256 startingHeaderTimestamp, uint256 headerCount); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "authorizationRequired", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "authorize", + "inputs": [ + { + "name": "submitter", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "currentEpoch", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint64", + "internalType": "uint64" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "deauthorize", + "inputs": [ + { + "name": "submitter", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "genesis", + "inputs": [ + { + "name": "genesisHeader", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "genesisHeight", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "genesisProofLength", + "type": "uint64", + "internalType": "uint64" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "genesisEpoch", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint64", + "internalType": "uint64" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getBlockDifficulty", + "inputs": [ + { + "name": "blockNumber", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getCurrentAndPrevEpochDifficulty", + "inputs": [], + "outputs": [ + { + "name": "current", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "previous", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getCurrentEpochDifficulty", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getEpochDifficulty", + "inputs": [ + { + "name": "epochNumber", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getPrevEpochDifficulty", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getRelayRange", + "inputs": [], + "outputs": [ + { + "name": "relayGenesis", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "currentEpochEnd", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isAuthorized", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "owner", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "proofLength", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint64", + "internalType": "uint64" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "ready", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "renounceOwnership", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "retarget", + "inputs": [ + { + "name": "headers", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setAuthorizationStatus", + "inputs": [ + { + "name": "status", + "type": "bool", + "internalType": "bool" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setProofLength", + "inputs": [ + { + "name": "newLength", + "type": "uint64", + "internalType": "uint64" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "transferOwnership", + "inputs": [ + { + "name": "newOwner", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "validateChain", + "inputs": [ + { + "name": "headers", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [ + { + "name": "startingHeaderTimestamp", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "headerCount", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "AuthorizationRequirementChanged", + "inputs": [ + { + "name": "newStatus", + "type": "bool", + "indexed": false, + "internalType": "bool" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Genesis", + "inputs": [ + { + "name": "blockHeight", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "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": "ProofLengthChanged", + "inputs": [ + { + "name": "newLength", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Retarget", + "inputs": [ + { + "name": "oldDifficulty", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "newDifficulty", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "SubmitterAuthorized", + "inputs": [ + { + "name": "submitter", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "SubmitterDeauthorized", + "inputs": [ + { + "name": "submitter", + "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 LightRelay { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x6080604052348015600e575f5ffd5b50601633601a565b6069565b5f80546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b6124cb806100765f395ff3fe608060405234801561000f575f5ffd5b5060043610610179575f3560e01c8063715018a6116100d2578063b6a5d7de11610088578063f2fde38b11610063578063f2fde38b1461034a578063f5619fda1461035d578063fe9fbb8014610377575f5ffd5b8063b6a5d7de14610310578063b70e6be614610323578063eb8695ef14610337575f5ffd5b80637ca5b1dd116100b85780637ca5b1dd146102b15780638da5cb5b146102c457806395410d2b146102eb575f5ffd5b8063715018a6146102705780637667180814610278575f5ffd5b806327c97fa5116101325780634ca49f511161010d5780634ca49f5114610216578063620414e6146102295780636defbf801461023c575f5ffd5b806327c97fa5146101f05780632b97be24146102035780633a1b77b01461020b575f5ffd5b8063113764be11610162578063113764be146101c0578063189179a3146101c857806319c9aa32146101db575f5ffd5b806306a274221461017d57806310b76ed8146101a3575b5f5ffd5b61019061018b366004612002565b610399565b6040519081526020015b60405180910390f35b6101ab6103af565b6040805192835260208301919091520161019a565b600254610190565b6101ab6101d6366004612046565b610413565b6101ee6101e9366004612152565b610892565b005b6101ee6101fe36600461216b565b610af0565b600354610190565b6002546003546101ab565b6101ee61022436600461219e565b610bd1565b610190610237366004612002565b61102c565b5f546102609074010000000000000000000000000000000000000000900460ff1681565b604051901515815260200161019a565b6101ee611154565b6001546102989068010000000000000000900467ffffffffffffffff1681565b60405167ffffffffffffffff909116815260200161019a565b6101ee6102bf366004612046565b6111c5565b5f5460405173ffffffffffffffffffffffffffffffffffffffff909116815260200161019a565b5f54610260907501000000000000000000000000000000000000000000900460ff1681565b6101ee61031e36600461216b565b611796565b6001546102989067ffffffffffffffff1681565b6101ee610345366004612223565b61187a565b6101ee61035836600461216b565b611959565b5f5461029890600160b01b900467ffffffffffffffff1681565b61026061038536600461216b565b60056020525f908152604090205460ff1681565b5f6103a96102376107e08461229c565b92915050565b6001545f9081906103cc9067ffffffffffffffff166107e06122af565b60015467ffffffffffffffff91821693506103f79168010000000000000000909104166107e06122af565b610403906107df6122d9565b67ffffffffffffffff1690509091565b5f5f6050835161042391906122f9565b156104755760405162461bcd60e51b815260206004820152601560248201527f496e76616c696420686561646572206c656e677468000000000000000000000060448201526064015b60405180910390fd5b60508351610483919061229c565b905060018111801561049657506107e081105b6104e25760405162461bcd60e51b815260206004820152601960248201527f496e76616c6964206e756d626572206f66206865616465727300000000000000604482015260640161046c565b6104eb83611a54565b63ffffffff1691505f80610500858280611a87565b6040805180820182525f808252602080830182905260015467ffffffffffffffff6801000000000000000090910416808352600482529184902084518086019095525463ffffffff8116855264010000000090047bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1690840152939550919350909190825b815163ffffffff168810156105f35761059b60018461230c565b5f8181526004602090815260409182902082518084019093525463ffffffff8116835264010000000090047bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1690820152909350919050610581565b815163ffffffff1661066d5760405162461bcd60e51b815260206004820152602b60248201527f43616e6e6f742076616c696461746520636861696e73206265666f726520726560448201527f6c61792067656e65736973000000000000000000000000000000000000000000606482015260840161046c565b81602001517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1685146107755780602001517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1685036106c757905082610775565b6106d260018461230c565b5f8181526004602090815260409182902082518084019093525463ffffffff8116835264010000000090047bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1690820181905291945092915085146107755760405162461bcd60e51b815260206004820152601e60248201527f496e76616c69642074617267657420696e2068656164657220636861696e0000604482015260640161046c565b60015b87811015610886575f6107968b61079084605061231f565b8a611a87565b60208601519098509091507bffffffffffffffffffffffffffffffffffffffffffffffffffffffff16871461087c575f6107db6107d484605061231f565b8d90611b5e565b845163ffffffff91821692501615801590610817575083602001517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1688145b80156108295750835163ffffffff1681145b6108755760405162461bcd60e51b815260206004820152601e60248201527f496e76616c69642074617267657420696e2068656164657220636861696e0000604482015260640161046c565b5091925084915b9650600101610778565b50505050505050915091565b5f5474010000000000000000000000000000000000000000900460ff166108fb5760405162461bcd60e51b815260206004820152601a60248201527f52656c6179206973206e6f7420726561647920666f7220757365000000000000604482015260640161046c565b5f5473ffffffffffffffffffffffffffffffffffffffff1633146109615760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161046c565b6107e08167ffffffffffffffff16106109bc5760405162461bcd60e51b815260206004820152601660248201527f50726f6f66206c656e6774682065786365737369766500000000000000000000604482015260640161046c565b5f8167ffffffffffffffff1611610a155760405162461bcd60e51b815260206004820152601c60248201527f50726f6f66206c656e677468206d6179206e6f74206265207a65726f00000000604482015260640161046c565b5f5467ffffffffffffffff600160b01b909104811690821603610a7a5760405162461bcd60e51b815260206004820152601660248201527f50726f6f66206c656e67746820756e6368616e67656400000000000000000000604482015260640161046c565b5f80547fffff0000000000000000ffffffffffffffffffffffffffffffffffffffffffff16600160b01b67ffffffffffffffff8416908102919091179091556040519081527f3e9f904d8cf11753c79b67c8259c582056d4a7d8af120f81257a59eeb8824b96906020015b60405180910390a150565b5f5473ffffffffffffffffffffffffffffffffffffffff163314610b565760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161046c565b73ffffffffffffffffffffffffffffffffffffffff81165f8181526005602090815260409182902080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0016905590519182527f7498b96beeabea5ad3139f1a2861a03e480034254e36b10aae2e6e42ad7b4b689101610ae5565b5f5473ffffffffffffffffffffffffffffffffffffffff163314610c375760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161046c565b5f5474010000000000000000000000000000000000000000900460ff1615610ca15760405162461bcd60e51b815260206004820152601960248201527f47656e6573697320616c726561647920706572666f726d656400000000000000604482015260640161046c565b60508314610cf15760405162461bcd60e51b815260206004820152601d60248201527f496e76616c69642067656e6573697320686561646572206c656e677468000000604482015260640161046c565b610cfd6107e0836122f9565b15610d705760405162461bcd60e51b815260206004820152602560248201527f496e76616c696420686569676874206f662072656c61792067656e657369732060448201527f626c6f636b000000000000000000000000000000000000000000000000000000606482015260840161046c565b6107e08167ffffffffffffffff1610610dcb5760405162461bcd60e51b815260206004820152601660248201527f50726f6f66206c656e6774682065786365737369766500000000000000000000604482015260640161046c565b5f8167ffffffffffffffff1611610e245760405162461bcd60e51b815260206004820152601c60248201527f50726f6f66206c656e677468206d6179206e6f74206265207a65726f00000000604482015260640161046c565b610e306107e08361229c565b600180547fffffffffffffffffffffffffffffffff000000000000000000000000000000001667ffffffffffffffff929092169182176801000000000000000092909202919091179055604080516020601f86018190048102820181019092528481525f91610eb9919087908790819084018382808284375f92019190915250611b7e92505050565b90505f610efa86868080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250611a5492505050565b60408051808201825263ffffffff9283168082527bffffffffffffffffffffffffffffffffffffffffffffffffffffffff808716602080850191825260015467ffffffffffffffff9081165f908152600490925295812094519151909216640100000000029516949094179091558254918616600160b01b027fffff0000000000000000ffffffffffffffffffffffffffffffffffffffffffff909216919091179091559050610fa982611b89565b6002555f80547fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff16740100000000000000000000000000000000000000001790556040517f2381d16925551c2fb1a5edfcf4fce2f6d085e1f85f4b88340c09c9d191f9d4e99061101c9086815260200190565b60405180910390a1505050505050565b6001545f9067ffffffffffffffff1682101561108a5760405162461bcd60e51b815260206004820152601d60248201527f45706f6368206973206265666f72652072656c61792067656e65736973000000604482015260640161046c565b60015468010000000000000000900467ffffffffffffffff168211156111175760405162461bcd60e51b8152602060048201526024808201527f45706f6368206973206e6f742070726f76656e20746f207468652072656c617960448201527f2079657400000000000000000000000000000000000000000000000000000000606482015260840161046c565b5f828152600460205260409020546103a99064010000000090047bffffffffffffffffffffffffffffffffffffffffffffffffffffffff16611b89565b5f5473ffffffffffffffffffffffffffffffffffffffff1633146111ba5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161046c565b6111c35f611bb0565b565b5f5474010000000000000000000000000000000000000000900460ff1661122e5760405162461bcd60e51b815260206004820152601a60248201527f52656c6179206973206e6f7420726561647920666f7220757365000000000000604482015260640161046c565b5f547501000000000000000000000000000000000000000000900460ff16156112af57335f9081526005602052604090205460ff166112af5760405162461bcd60e51b815260206004820152601660248201527f5375626d697474657220756e617574686f72697a656400000000000000000000604482015260640161046c565b5f546112cd90600160b01b900467ffffffffffffffff1660026122af565b6112d89060506122af565b67ffffffffffffffff168151146113315760405162461bcd60e51b815260206004820152601560248201527f496e76616c696420686561646572206c656e6774680000000000000000000000604482015260640161046c565b60015468010000000000000000900467ffffffffffffffff165f908152600460205260408120805490916401000000009091047bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1690805b5f54600160b01b900467ffffffffffffffff1681101561143a575f806113b6876113b085605061231f565b86611a87565b9150915084811461142f5760405162461bcd60e51b815260206004820152602660248201527f496e76616c69642074617267657420696e207072652d7265746172676574206860448201527f6561646572730000000000000000000000000000000000000000000000000000606482015260840161046c565b509150600101611385565b505f805461147b9061145f90600190600160b01b900467ffffffffffffffff16612336565b61146a9060506122af565b869067ffffffffffffffff16611b5e565b63ffffffff1690504281106114d25760405162461bcd60e51b815260206004820152601e60248201527f45706f63682063616e6e6f7420656e6420696e20746865206675747572650000604482015260640161046c565b83545f906114e890859063ffffffff1684611c24565b5f80549192509081906115229061151190600160b01b900467ffffffffffffffff1660506122af565b899067ffffffffffffffff16611b5e565b5f5463ffffffff919091169150600160b01b900467ffffffffffffffff165b5f5461155f90600160b01b900467ffffffffffffffff1660026122af565b67ffffffffffffffff16811015611665575f806115818b61079085605061231f565b91509150845f036115e55780945080861681146115e05760405162461bcd60e51b815260206004820152601b60248201527f496e76616c69642074617267657420696e206e65772065706f63680000000000604482015260640161046c565b61165a565b84811461165a5760405162461bcd60e51b815260206004820152602760248201527f556e657870656374656420746172676574206368616e6765206166746572207260448201527f6574617267657400000000000000000000000000000000000000000000000000606482015260840161046c565b509550600101611541565b50600160089054906101000a900467ffffffffffffffff16600161168991906122d9565b6001805467ffffffffffffffff928316680100000000000000009081027fffffffffffffffffffffffffffffffff0000000000000000ffffffffffffffff909216919091179182905560408051808201825263ffffffff80871682527bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8089166020808501918252959096049096165f908152600490945291832090519351909416640100000000029216919091179091556002549061174484611b89565b6003839055600281905560408051848152602081018390529192507fa282ee798b132f9dc11e06cd4d8e767e562be8709602ca14fea7ab3392acbdab910160405180910390a150505050505050505050565b5f5473ffffffffffffffffffffffffffffffffffffffff1633146117fc5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161046c565b73ffffffffffffffffffffffffffffffffffffffff81165f8181526005602090815260409182902080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0016600117905590519182527fd53649b492f738bb59d6825099b5955073efda0bf9e3a7ad20da22e110122e299101610ae5565b5f5473ffffffffffffffffffffffffffffffffffffffff1633146118e05760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161046c565b5f80548215157501000000000000000000000000000000000000000000027fffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffffff9091161790556040517fd813b248d49c8bf08be2b6947126da6763df310beed7bea97756456c5727419a90610ae590831515815260200190565b5f5473ffffffffffffffffffffffffffffffffffffffff1633146119bf5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161046c565b73ffffffffffffffffffffffffffffffffffffffff8116611a485760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f6464726573730000000000000000000000000000000000000000000000000000606482015260840161046c565b611a5181611bb0565b50565b5f6103a9611a6183611cb6565b60d881901c63ff00ff001662ff00ff60e89290921c9190911617601081811b91901c1790565b5f808215611ae657611a9a858585611cc2565b611ae65760405162461bcd60e51b815260206004820152600d60248201527f496e76616c696420636861696e00000000000000000000000000000000000000604482015260640161046c565b611af08585611ceb565b9050611afe85856050611d88565b9150611b0a8282611dad565b611b565760405162461bcd60e51b815260206004820152600c60248201527f496e76616c696420776f726b0000000000000000000000000000000000000000604482015260640161046c565b935093915050565b5f611b77611a61611b70846044612356565b8590611f03565b9392505050565b5f6103a9825f611ceb565b5f6103a97bffff000000000000000000000000000000000000000000000000000083611f11565b5f805473ffffffffffffffffffffffffffffffffffffffff8381167fffffffffffffffffffffffff0000000000000000000000000000000000000000831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b5f80611c308385611f1c565b9050611c40621275006004611f11565b811015611c5857611c55621275006004611f11565b90505b611c66621275006004611f77565b811115611c7e57611c7b621275006004611f77565b90505b5f611c9682611c908862010000611f11565b90611f77565b9050611cac62010000611c908362127500611f11565b9695505050505050565b5f6103a9826044611f03565b5f80611cce8585611fea565b9050828114611ce0575f915050611b77565b506001949350505050565b5f80611cfb611b70846048612356565b60e81c90505f84611d0d85604b612356565b81518110611d1d57611d1d612369565b016020015160f81c90505f611d4f835f60108262ffffff16901c8261ff001660108462ffffff16901b17179050919050565b62ffffff1690505f611d62600384612396565b60ff169050611d738161010061248a565b611d7d908361231f565b979650505050505050565b5f60205f8385602001870160025afa5060205f60205f60025afa50505f519392505050565b5f82611dba57505f6103a9565b81611efb845f8190506008817eff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff16901b600882901c7eff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff161790506010817dffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff16901b601082901c7dffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff161790506020817bffffffff00000000ffffffff00000000ffffffff00000000ffffffff16901b602082901c7bffffffff00000000ffffffff00000000ffffffff00000000ffffffff1617905060408177ffffffffffffffff0000000000000000ffffffffffffffff16901b604082901c77ffffffffffffffff0000000000000000ffffffffffffffff16179050608081901b608082901c179050919050565b109392505050565b5f611b778383016020015190565b5f611b77828461229c565b5f82821115611f6d5760405162461bcd60e51b815260206004820152601d60248201527f556e646572666c6f7720647572696e67207375627472616374696f6e2e000000604482015260640161046c565b611b77828461230c565b5f825f03611f8657505f6103a9565b611f90828461231f565b905081611f9d848361229c565b146103a95760405162461bcd60e51b815260206004820152601f60248201527f4f766572666c6f7720647572696e67206d756c7469706c69636174696f6e2e00604482015260640161046c565b5f611b77611ff9836004612356565b84016020015190565b5f60208284031215612012575f5ffd5b5035919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b5f60208284031215612056575f5ffd5b813567ffffffffffffffff81111561206c575f5ffd5b8201601f8101841361207c575f5ffd5b803567ffffffffffffffff81111561209657612096612019565b6040517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0603f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f8501160116810181811067ffffffffffffffff8211171561210257612102612019565b604052818152828201602001861015612119575f5ffd5b816020840160208301375f91810160200191909152949350505050565b803567ffffffffffffffff8116811461214d575f5ffd5b919050565b5f60208284031215612162575f5ffd5b611b7782612136565b5f6020828403121561217b575f5ffd5b813573ffffffffffffffffffffffffffffffffffffffff81168114611b77575f5ffd5b5f5f5f5f606085870312156121b1575f5ffd5b843567ffffffffffffffff8111156121c7575f5ffd5b8501601f810187136121d7575f5ffd5b803567ffffffffffffffff8111156121ed575f5ffd5b8760208284010111156121fe575f5ffd5b602091820195509350850135915061221860408601612136565b905092959194509250565b5f60208284031215612233575f5ffd5b81358015158114611b77575f5ffd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f826122aa576122aa612242565b500490565b67ffffffffffffffff81811683821602908116908181146122d2576122d261226f565b5092915050565b67ffffffffffffffff81811683821601908111156103a9576103a961226f565b5f8261230757612307612242565b500690565b818103818111156103a9576103a961226f565b80820281158282048414176103a9576103a961226f565b67ffffffffffffffff82811682821603908111156103a9576103a961226f565b808201808211156103a9576103a961226f565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b60ff82811682821603908111156103a9576103a961226f565b6001815b6001841115611b56578085048111156123ce576123ce61226f565b60018416156123dc57908102905b60019390931c9280026123b3565b5f826123f8575060016103a9565b8161240457505f6103a9565b816001811461241a576002811461242457612440565b60019150506103a9565b60ff8411156124355761243561226f565b50506001821b6103a9565b5060208310610133831016604e8410600b8410161715612463575081810a6103a9565b61246f5f1984846123af565b805f19048211156124825761248261226f565b029392505050565b5f611b7783836123ea56fea2646970667358221220657fb9db76302ad186123eac9bace1577619c6747e6ab97a11719f59460d925e64736f6c634300081c0033 + /// ``` + #[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`\x163`\x1AV[`iV[_\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x01`\x01`\xA0\x1B\x03\x19\x83\x16\x81\x17\x84U`@Q\x91\x90\x92\x16\x92\x83\x91\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x91\x90\xA3PPV[a$\xCB\x80a\0v_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01yW_5`\xE0\x1C\x80cqP\x18\xA6\x11a\0\xD2W\x80c\xB6\xA5\xD7\xDE\x11a\0\x88W\x80c\xF2\xFD\xE3\x8B\x11a\0cW\x80c\xF2\xFD\xE3\x8B\x14a\x03JW\x80c\xF5a\x9F\xDA\x14a\x03]W\x80c\xFE\x9F\xBB\x80\x14a\x03wW__\xFD[\x80c\xB6\xA5\xD7\xDE\x14a\x03\x10W\x80c\xB7\x0Ek\xE6\x14a\x03#W\x80c\xEB\x86\x95\xEF\x14a\x037W__\xFD[\x80c|\xA5\xB1\xDD\x11a\0\xB8W\x80c|\xA5\xB1\xDD\x14a\x02\xB1W\x80c\x8D\xA5\xCB[\x14a\x02\xC4W\x80c\x95A\r+\x14a\x02\xEBW__\xFD[\x80cqP\x18\xA6\x14a\x02pW\x80cvg\x18\x08\x14a\x02xW__\xFD[\x80c'\xC9\x7F\xA5\x11a\x012W\x80cL\xA4\x9FQ\x11a\x01\rW\x80cL\xA4\x9FQ\x14a\x02\x16W\x80cb\x04\x14\xE6\x14a\x02)W\x80cm\xEF\xBF\x80\x14a\x02\x9F\x90M\x8C\xF1\x17S\xC7\x9Bg\xC8%\x9CX V\xD4\xA7\xD8\xAF\x12\x0F\x81%zY\xEE\xB8\x82K\x96\x90` \x01[`@Q\x80\x91\x03\x90\xA1PV[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x0BVW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16_\x81\x81R`\x05` \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\x90Q\x91\x82R\x7Ft\x98\xB9k\xEE\xAB\xEAZ\xD3\x13\x9F\x1A(a\xA0>H\x004%N6\xB1\n\xAE.nB\xAD{Kh\x91\x01a\n\xE5V[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x0C7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[_Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x0C\xA1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FGenesis already performed\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[`P\x83\x14a\x0C\xF1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FInvalid genesis header length\0\0\0`D\x82\x01R`d\x01a\x04lV[a\x0C\xFDa\x07\xE0\x83a\"\xF9V[\x15a\rpW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`%`$\x82\x01R\x7FInvalid height of relay genesis `D\x82\x01R\x7Fblock\0\0\0\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\x04lV[a\x07\xE0\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x10a\r\xCBW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7FProof length excessive\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x11a\x0E$W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FProof length may not be zero\0\0\0\0`D\x82\x01R`d\x01a\x04lV[a\x0E0a\x07\xE0\x83a\"\x9CV[`\x01\x80T\x7F\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\0\0\x16g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x90\x92\x16\x91\x82\x17h\x01\0\0\0\0\0\0\0\0\x92\x90\x92\x02\x91\x90\x91\x17\x90U`@\x80Q` `\x1F\x86\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x84\x81R_\x91a\x0E\xB9\x91\x90\x87\x90\x87\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RPa\x1B~\x92PPPV[\x90P_a\x0E\xFA\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\x91RPa\x1AT\x92PPPV[`@\x80Q\x80\x82\x01\x82Rc\xFF\xFF\xFF\xFF\x92\x83\x16\x80\x82R{\xFF\xFF\xFF\xFF\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\x87\x16` \x80\x85\x01\x91\x82R`\x01Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16_\x90\x81R`\x04\x90\x92R\x95\x81 \x94Q\x91Q\x90\x92\x16d\x01\0\0\0\0\x02\x95\x16\x94\x90\x94\x17\x90\x91U\x82T\x91\x86\x16`\x01`\xB0\x1B\x02\x7F\xFF\xFF\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\x90\x92\x16\x91\x90\x91\x17\x90\x91U\x90Pa\x0F\xA9\x82a\x1B\x89V[`\x02U_\x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x17\x90U`@Q\x7F#\x81\xD1i%U\x1C/\xB1\xA5\xED\xFC\xF4\xFC\xE2\xF6\xD0\x85\xE1\xF8_K\x884\x0C\t\xC9\xD1\x91\xF9\xD4\xE9\x90a\x10\x1C\x90\x86\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA1PPPPPPV[`\x01T_\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82\x10\x15a\x10\x8AW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FEpoch is before relay genesis\0\0\0`D\x82\x01R`d\x01a\x04lV[`\x01Th\x01\0\0\0\0\0\0\0\0\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82\x11\x15a\x11\x17W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FEpoch is not proven to the relay`D\x82\x01R\x7F yet\0\0\0\0\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\x04lV[_\x82\x81R`\x04` R`@\x90 Ta\x03\xA9\x90d\x01\0\0\0\0\x90\x04{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x1B\x89V[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x11\xBAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[a\x11\xC3_a\x1B\xB0V[V[_Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16a\x12.W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FRelay is not ready for use\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[_Tu\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x12\xAFW3_\x90\x81R`\x05` R`@\x90 T`\xFF\x16a\x12\xAFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7FSubmitter unauthorized\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[_Ta\x12\xCD\x90`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02a\"\xAFV[a\x12\xD8\x90`Pa\"\xAFV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81Q\x14a\x131W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FInvalid header length\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[`\x01Th\x01\0\0\0\0\0\0\0\0\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16_\x90\x81R`\x04` R`@\x81 \x80T\x90\x91d\x01\0\0\0\0\x90\x91\x04{\xFF\xFF\xFF\xFF\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\x90\x80[_T`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x14:W_\x80a\x13\xB6\x87a\x13\xB0\x85`Pa#\x1FV[\x86a\x1A\x87V[\x91P\x91P\x84\x81\x14a\x14/W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FInvalid target in pre-retarget h`D\x82\x01R\x7Feaders\0\0\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\x04lV[P\x91P`\x01\x01a\x13\x85V[P_\x80Ta\x14{\x90a\x14_\x90`\x01\x90`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a#6V[a\x14j\x90`Pa\"\xAFV[\x86\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x1B^V[c\xFF\xFF\xFF\xFF\x16\x90PB\x81\x10a\x14\xD2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FEpoch cannot end in the future\0\0`D\x82\x01R`d\x01a\x04lV[\x83T_\x90a\x14\xE8\x90\x85\x90c\xFF\xFF\xFF\xFF\x16\x84a\x1C$V[_\x80T\x91\x92P\x90\x81\x90a\x15\"\x90a\x15\x11\x90`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`Pa\"\xAFV[\x89\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x1B^V[_Tc\xFF\xFF\xFF\xFF\x91\x90\x91\x16\x91P`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16[_Ta\x15_\x90`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02a\"\xAFV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x16eW_\x80a\x15\x81\x8Ba\x07\x90\x85`Pa#\x1FV[\x91P\x91P\x84_\x03a\x15\xE5W\x80\x94P\x80\x86\x16\x81\x14a\x15\xE0W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FInvalid target in new epoch\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[a\x16ZV[\x84\x81\x14a\x16ZW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FUnexpected target change after r`D\x82\x01R\x7Fetarget\0\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\x04lV[P\x95P`\x01\x01a\x15AV[P`\x01`\x08\x90T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01a\x16\x89\x91\x90a\"\xD9V[`\x01\x80Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16h\x01\0\0\0\0\0\0\0\0\x90\x81\x02\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16\x91\x90\x91\x17\x91\x82\x90U`@\x80Q\x80\x82\x01\x82Rc\xFF\xFF\xFF\xFF\x80\x87\x16\x82R{\xFF\xFF\xFF\xFF\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\x89\x16` \x80\x85\x01\x91\x82R\x95\x90\x96\x04\x90\x96\x16_\x90\x81R`\x04\x90\x94R\x91\x83 \x90Q\x93Q\x90\x94\x16d\x01\0\0\0\0\x02\x92\x16\x91\x90\x91\x17\x90\x91U`\x02T\x90a\x17D\x84a\x1B\x89V[`\x03\x83\x90U`\x02\x81\x90U`@\x80Q\x84\x81R` \x81\x01\x83\x90R\x91\x92P\x7F\xA2\x82\xEEy\x8B\x13/\x9D\xC1\x1E\x06\xCDM\x8Ev~V+\xE8p\x96\x02\xCA\x14\xFE\xA7\xAB3\x92\xAC\xBD\xAB\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPPV[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x17\xFCW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16_\x81\x81R`\x05` \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`\x01\x17\x90U\x90Q\x91\x82R\x7F\xD56I\xB4\x92\xF78\xBBY\xD6\x82P\x99\xB5\x95Ps\xEF\xDA\x0B\xF9\xE3\xA7\xAD \xDA\"\xE1\x10\x12.)\x91\x01a\n\xE5V[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x18\xE0W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[_\x80T\x82\x15\x15u\x01\0\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\xFF\xFF\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x17\x90U`@Q\x7F\xD8\x13\xB2H\xD4\x9C\x8B\xF0\x8B\xE2\xB6\x94q&\xDAgc\xDF1\x0B\xEE\xD7\xBE\xA9wVElW'A\x9A\x90a\n\xE5\x90\x83\x15\x15\x81R` \x01\x90V[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x19\xBFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16a\x1AHW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01R\x7Fddress\0\0\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\x04lV[a\x1AQ\x81a\x1B\xB0V[PV[_a\x03\xA9a\x1Aa\x83a\x1C\xB6V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80\x82\x15a\x1A\xE6Wa\x1A\x9A\x85\x85\x85a\x1C\xC2V[a\x1A\xE6W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FInvalid chain\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[a\x1A\xF0\x85\x85a\x1C\xEBV[\x90Pa\x1A\xFE\x85\x85`Pa\x1D\x88V[\x91Pa\x1B\n\x82\x82a\x1D\xADV[a\x1BVW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x0C`$\x82\x01R\x7FInvalid work\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[\x93P\x93\x91PPV[_a\x1Bwa\x1Aaa\x1Bp\x84`Da#VV[\x85\x90a\x1F\x03V[\x93\x92PPPV[_a\x03\xA9\x82_a\x1C\xEBV[_a\x03\xA9{\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\x83a\x1F\x11V[_\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x81\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\x83\x16\x81\x17\x84U`@Q\x91\x90\x92\x16\x92\x83\x91\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x91\x90\xA3PPV[_\x80a\x1C0\x83\x85a\x1F\x1CV[\x90Pa\x1C@b\x12u\0`\x04a\x1F\x11V[\x81\x10\x15a\x1CXWa\x1CUb\x12u\0`\x04a\x1F\x11V[\x90P[a\x1Cfb\x12u\0`\x04a\x1FwV[\x81\x11\x15a\x1C~Wa\x1C{b\x12u\0`\x04a\x1FwV[\x90P[_a\x1C\x96\x82a\x1C\x90\x88b\x01\0\0a\x1F\x11V[\x90a\x1FwV[\x90Pa\x1C\xACb\x01\0\0a\x1C\x90\x83b\x12u\0a\x1F\x11V[\x96\x95PPPPPPV[_a\x03\xA9\x82`Da\x1F\x03V[_\x80a\x1C\xCE\x85\x85a\x1F\xEAV[\x90P\x82\x81\x14a\x1C\xE0W_\x91PPa\x1BwV[P`\x01\x94\x93PPPPV[_\x80a\x1C\xFBa\x1Bp\x84`Ha#VV[`\xE8\x1C\x90P_\x84a\x1D\r\x85`Ka#VV[\x81Q\x81\x10a\x1D\x1DWa\x1D\x1Da#iV[\x01` \x01Q`\xF8\x1C\x90P_a\x1DO\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1Db`\x03\x84a#\x96V[`\xFF\x16\x90Pa\x1Ds\x81a\x01\0a$\x8AV[a\x1D}\x90\x83a#\x1FV[\x97\x96PPPPPPPV[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x82a\x1D\xBAWP_a\x03\xA9V[\x81a\x1E\xFB\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x10\x93\x92PPPV[_a\x1Bw\x83\x83\x01` \x01Q\x90V[_a\x1Bw\x82\x84a\"\x9CV[_\x82\x82\x11\x15a\x1FmW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x04lV[a\x1Bw\x82\x84a#\x0CV[_\x82_\x03a\x1F\x86WP_a\x03\xA9V[a\x1F\x90\x82\x84a#\x1FV[\x90P\x81a\x1F\x9D\x84\x83a\"\x9CV[\x14a\x03\xA9W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x04lV[_a\x1Bwa\x1F\xF9\x83`\x04a#VV[\x84\x01` \x01Q\x90V[_` \x82\x84\x03\x12\x15a \x12W__\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_R`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a VW__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a lW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a |W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a \x96Wa \x96a \x19V[`@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!\x02Wa!\x02a \x19V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a!\x19W__\xFD[\x81` \x84\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a!MW__\xFD[\x91\x90PV[_` \x82\x84\x03\x12\x15a!bW__\xFD[a\x1Bw\x82a!6V[_` \x82\x84\x03\x12\x15a!{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\x14a\x1BwW__\xFD[____``\x85\x87\x03\x12\x15a!\xB1W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a!\xC7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a!\xD7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a!\xEDW__\xFD[\x87` \x82\x84\x01\x01\x11\x15a!\xFEW__\xFD[` \x91\x82\x01\x95P\x93P\x85\x015\x91Pa\"\x18`@\x86\x01a!6V[\x90P\x92\x95\x91\x94P\x92PV[_` \x82\x84\x03\x12\x15a\"3W__\xFD[\x815\x80\x15\x15\x81\x14a\x1BwW__\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`\x12`\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`\x11`\x04R`$_\xFD[_\x82a\"\xAAWa\"\xAAa\"BV[P\x04\x90V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x02\x90\x81\x16\x90\x81\x81\x14a\"\xD2Wa\"\xD2a\"oV[P\x92\x91PPV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x03\xA9Wa\x03\xA9a\"oV[_\x82a#\x07Wa#\x07a\"BV[P\x06\x90V[\x81\x81\x03\x81\x81\x11\x15a\x03\xA9Wa\x03\xA9a\"oV[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x03\xA9Wa\x03\xA9a\"oV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x03\xA9Wa\x03\xA9a\"oV[\x80\x82\x01\x80\x82\x11\x15a\x03\xA9Wa\x03\xA9a\"oV[\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[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x03\xA9Wa\x03\xA9a\"oV[`\x01\x81[`\x01\x84\x11\x15a\x1BVW\x80\x85\x04\x81\x11\x15a#\xCEWa#\xCEa\"oV[`\x01\x84\x16\x15a#\xDCW\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a#\xB3V[_\x82a#\xF8WP`\x01a\x03\xA9V[\x81a$\x04WP_a\x03\xA9V[\x81`\x01\x81\x14a$\x1AW`\x02\x81\x14a$$Wa$@V[`\x01\x91PPa\x03\xA9V[`\xFF\x84\x11\x15a$5Wa$5a\"oV[PP`\x01\x82\x1Ba\x03\xA9V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a$cWP\x81\x81\na\x03\xA9V[a$o_\x19\x84\x84a#\xAFV[\x80_\x19\x04\x82\x11\x15a$\x82Wa$\x82a\"oV[\x02\x93\x92PPPV[_a\x1Bw\x83\x83a#\xEAV\xFE\xA2dipfsX\"\x12 e\x7F\xB9\xDBv0*\xD1\x86\x12>\xAC\x9B\xAC\xE1Wv\x19\xC6t~j\xB9z\x11q\x9FYF\r\x92^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\x01yW_5`\xE0\x1C\x80cqP\x18\xA6\x11a\0\xD2W\x80c\xB6\xA5\xD7\xDE\x11a\0\x88W\x80c\xF2\xFD\xE3\x8B\x11a\0cW\x80c\xF2\xFD\xE3\x8B\x14a\x03JW\x80c\xF5a\x9F\xDA\x14a\x03]W\x80c\xFE\x9F\xBB\x80\x14a\x03wW__\xFD[\x80c\xB6\xA5\xD7\xDE\x14a\x03\x10W\x80c\xB7\x0Ek\xE6\x14a\x03#W\x80c\xEB\x86\x95\xEF\x14a\x037W__\xFD[\x80c|\xA5\xB1\xDD\x11a\0\xB8W\x80c|\xA5\xB1\xDD\x14a\x02\xB1W\x80c\x8D\xA5\xCB[\x14a\x02\xC4W\x80c\x95A\r+\x14a\x02\xEBW__\xFD[\x80cqP\x18\xA6\x14a\x02pW\x80cvg\x18\x08\x14a\x02xW__\xFD[\x80c'\xC9\x7F\xA5\x11a\x012W\x80cL\xA4\x9FQ\x11a\x01\rW\x80cL\xA4\x9FQ\x14a\x02\x16W\x80cb\x04\x14\xE6\x14a\x02)W\x80cm\xEF\xBF\x80\x14a\x02\x9F\x90M\x8C\xF1\x17S\xC7\x9Bg\xC8%\x9CX V\xD4\xA7\xD8\xAF\x12\x0F\x81%zY\xEE\xB8\x82K\x96\x90` \x01[`@Q\x80\x91\x03\x90\xA1PV[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x0BVW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16_\x81\x81R`\x05` \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\x90Q\x91\x82R\x7Ft\x98\xB9k\xEE\xAB\xEAZ\xD3\x13\x9F\x1A(a\xA0>H\x004%N6\xB1\n\xAE.nB\xAD{Kh\x91\x01a\n\xE5V[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x0C7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[_Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x0C\xA1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FGenesis already performed\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[`P\x83\x14a\x0C\xF1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FInvalid genesis header length\0\0\0`D\x82\x01R`d\x01a\x04lV[a\x0C\xFDa\x07\xE0\x83a\"\xF9V[\x15a\rpW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`%`$\x82\x01R\x7FInvalid height of relay genesis `D\x82\x01R\x7Fblock\0\0\0\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\x04lV[a\x07\xE0\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x10a\r\xCBW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7FProof length excessive\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x11a\x0E$W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FProof length may not be zero\0\0\0\0`D\x82\x01R`d\x01a\x04lV[a\x0E0a\x07\xE0\x83a\"\x9CV[`\x01\x80T\x7F\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\0\0\x16g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x90\x92\x16\x91\x82\x17h\x01\0\0\0\0\0\0\0\0\x92\x90\x92\x02\x91\x90\x91\x17\x90U`@\x80Q` `\x1F\x86\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x84\x81R_\x91a\x0E\xB9\x91\x90\x87\x90\x87\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RPa\x1B~\x92PPPV[\x90P_a\x0E\xFA\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\x91RPa\x1AT\x92PPPV[`@\x80Q\x80\x82\x01\x82Rc\xFF\xFF\xFF\xFF\x92\x83\x16\x80\x82R{\xFF\xFF\xFF\xFF\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\x87\x16` \x80\x85\x01\x91\x82R`\x01Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16_\x90\x81R`\x04\x90\x92R\x95\x81 \x94Q\x91Q\x90\x92\x16d\x01\0\0\0\0\x02\x95\x16\x94\x90\x94\x17\x90\x91U\x82T\x91\x86\x16`\x01`\xB0\x1B\x02\x7F\xFF\xFF\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\x90\x92\x16\x91\x90\x91\x17\x90\x91U\x90Pa\x0F\xA9\x82a\x1B\x89V[`\x02U_\x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x17\x90U`@Q\x7F#\x81\xD1i%U\x1C/\xB1\xA5\xED\xFC\xF4\xFC\xE2\xF6\xD0\x85\xE1\xF8_K\x884\x0C\t\xC9\xD1\x91\xF9\xD4\xE9\x90a\x10\x1C\x90\x86\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA1PPPPPPV[`\x01T_\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82\x10\x15a\x10\x8AW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FEpoch is before relay genesis\0\0\0`D\x82\x01R`d\x01a\x04lV[`\x01Th\x01\0\0\0\0\0\0\0\0\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82\x11\x15a\x11\x17W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FEpoch is not proven to the relay`D\x82\x01R\x7F yet\0\0\0\0\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\x04lV[_\x82\x81R`\x04` R`@\x90 Ta\x03\xA9\x90d\x01\0\0\0\0\x90\x04{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x1B\x89V[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x11\xBAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[a\x11\xC3_a\x1B\xB0V[V[_Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16a\x12.W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FRelay is not ready for use\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[_Tu\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x12\xAFW3_\x90\x81R`\x05` R`@\x90 T`\xFF\x16a\x12\xAFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7FSubmitter unauthorized\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[_Ta\x12\xCD\x90`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02a\"\xAFV[a\x12\xD8\x90`Pa\"\xAFV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81Q\x14a\x131W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FInvalid header length\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[`\x01Th\x01\0\0\0\0\0\0\0\0\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16_\x90\x81R`\x04` R`@\x81 \x80T\x90\x91d\x01\0\0\0\0\x90\x91\x04{\xFF\xFF\xFF\xFF\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\x90\x80[_T`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x14:W_\x80a\x13\xB6\x87a\x13\xB0\x85`Pa#\x1FV[\x86a\x1A\x87V[\x91P\x91P\x84\x81\x14a\x14/W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FInvalid target in pre-retarget h`D\x82\x01R\x7Feaders\0\0\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\x04lV[P\x91P`\x01\x01a\x13\x85V[P_\x80Ta\x14{\x90a\x14_\x90`\x01\x90`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a#6V[a\x14j\x90`Pa\"\xAFV[\x86\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x1B^V[c\xFF\xFF\xFF\xFF\x16\x90PB\x81\x10a\x14\xD2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FEpoch cannot end in the future\0\0`D\x82\x01R`d\x01a\x04lV[\x83T_\x90a\x14\xE8\x90\x85\x90c\xFF\xFF\xFF\xFF\x16\x84a\x1C$V[_\x80T\x91\x92P\x90\x81\x90a\x15\"\x90a\x15\x11\x90`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`Pa\"\xAFV[\x89\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x1B^V[_Tc\xFF\xFF\xFF\xFF\x91\x90\x91\x16\x91P`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16[_Ta\x15_\x90`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02a\"\xAFV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x16eW_\x80a\x15\x81\x8Ba\x07\x90\x85`Pa#\x1FV[\x91P\x91P\x84_\x03a\x15\xE5W\x80\x94P\x80\x86\x16\x81\x14a\x15\xE0W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FInvalid target in new epoch\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[a\x16ZV[\x84\x81\x14a\x16ZW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FUnexpected target change after r`D\x82\x01R\x7Fetarget\0\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\x04lV[P\x95P`\x01\x01a\x15AV[P`\x01`\x08\x90T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01a\x16\x89\x91\x90a\"\xD9V[`\x01\x80Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16h\x01\0\0\0\0\0\0\0\0\x90\x81\x02\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16\x91\x90\x91\x17\x91\x82\x90U`@\x80Q\x80\x82\x01\x82Rc\xFF\xFF\xFF\xFF\x80\x87\x16\x82R{\xFF\xFF\xFF\xFF\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\x89\x16` \x80\x85\x01\x91\x82R\x95\x90\x96\x04\x90\x96\x16_\x90\x81R`\x04\x90\x94R\x91\x83 \x90Q\x93Q\x90\x94\x16d\x01\0\0\0\0\x02\x92\x16\x91\x90\x91\x17\x90\x91U`\x02T\x90a\x17D\x84a\x1B\x89V[`\x03\x83\x90U`\x02\x81\x90U`@\x80Q\x84\x81R` \x81\x01\x83\x90R\x91\x92P\x7F\xA2\x82\xEEy\x8B\x13/\x9D\xC1\x1E\x06\xCDM\x8Ev~V+\xE8p\x96\x02\xCA\x14\xFE\xA7\xAB3\x92\xAC\xBD\xAB\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPPV[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x17\xFCW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16_\x81\x81R`\x05` \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`\x01\x17\x90U\x90Q\x91\x82R\x7F\xD56I\xB4\x92\xF78\xBBY\xD6\x82P\x99\xB5\x95Ps\xEF\xDA\x0B\xF9\xE3\xA7\xAD \xDA\"\xE1\x10\x12.)\x91\x01a\n\xE5V[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x18\xE0W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[_\x80T\x82\x15\x15u\x01\0\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\xFF\xFF\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x17\x90U`@Q\x7F\xD8\x13\xB2H\xD4\x9C\x8B\xF0\x8B\xE2\xB6\x94q&\xDAgc\xDF1\x0B\xEE\xD7\xBE\xA9wVElW'A\x9A\x90a\n\xE5\x90\x83\x15\x15\x81R` \x01\x90V[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x19\xBFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16a\x1AHW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01R\x7Fddress\0\0\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\x04lV[a\x1AQ\x81a\x1B\xB0V[PV[_a\x03\xA9a\x1Aa\x83a\x1C\xB6V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80\x82\x15a\x1A\xE6Wa\x1A\x9A\x85\x85\x85a\x1C\xC2V[a\x1A\xE6W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FInvalid chain\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[a\x1A\xF0\x85\x85a\x1C\xEBV[\x90Pa\x1A\xFE\x85\x85`Pa\x1D\x88V[\x91Pa\x1B\n\x82\x82a\x1D\xADV[a\x1BVW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x0C`$\x82\x01R\x7FInvalid work\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[\x93P\x93\x91PPV[_a\x1Bwa\x1Aaa\x1Bp\x84`Da#VV[\x85\x90a\x1F\x03V[\x93\x92PPPV[_a\x03\xA9\x82_a\x1C\xEBV[_a\x03\xA9{\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\x83a\x1F\x11V[_\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x81\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\x83\x16\x81\x17\x84U`@Q\x91\x90\x92\x16\x92\x83\x91\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x91\x90\xA3PPV[_\x80a\x1C0\x83\x85a\x1F\x1CV[\x90Pa\x1C@b\x12u\0`\x04a\x1F\x11V[\x81\x10\x15a\x1CXWa\x1CUb\x12u\0`\x04a\x1F\x11V[\x90P[a\x1Cfb\x12u\0`\x04a\x1FwV[\x81\x11\x15a\x1C~Wa\x1C{b\x12u\0`\x04a\x1FwV[\x90P[_a\x1C\x96\x82a\x1C\x90\x88b\x01\0\0a\x1F\x11V[\x90a\x1FwV[\x90Pa\x1C\xACb\x01\0\0a\x1C\x90\x83b\x12u\0a\x1F\x11V[\x96\x95PPPPPPV[_a\x03\xA9\x82`Da\x1F\x03V[_\x80a\x1C\xCE\x85\x85a\x1F\xEAV[\x90P\x82\x81\x14a\x1C\xE0W_\x91PPa\x1BwV[P`\x01\x94\x93PPPPV[_\x80a\x1C\xFBa\x1Bp\x84`Ha#VV[`\xE8\x1C\x90P_\x84a\x1D\r\x85`Ka#VV[\x81Q\x81\x10a\x1D\x1DWa\x1D\x1Da#iV[\x01` \x01Q`\xF8\x1C\x90P_a\x1DO\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1Db`\x03\x84a#\x96V[`\xFF\x16\x90Pa\x1Ds\x81a\x01\0a$\x8AV[a\x1D}\x90\x83a#\x1FV[\x97\x96PPPPPPPV[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x82a\x1D\xBAWP_a\x03\xA9V[\x81a\x1E\xFB\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x10\x93\x92PPPV[_a\x1Bw\x83\x83\x01` \x01Q\x90V[_a\x1Bw\x82\x84a\"\x9CV[_\x82\x82\x11\x15a\x1FmW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x04lV[a\x1Bw\x82\x84a#\x0CV[_\x82_\x03a\x1F\x86WP_a\x03\xA9V[a\x1F\x90\x82\x84a#\x1FV[\x90P\x81a\x1F\x9D\x84\x83a\"\x9CV[\x14a\x03\xA9W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x04lV[_a\x1Bwa\x1F\xF9\x83`\x04a#VV[\x84\x01` \x01Q\x90V[_` \x82\x84\x03\x12\x15a \x12W__\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_R`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a VW__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a lW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a |W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a \x96Wa \x96a \x19V[`@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!\x02Wa!\x02a \x19V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a!\x19W__\xFD[\x81` \x84\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a!MW__\xFD[\x91\x90PV[_` \x82\x84\x03\x12\x15a!bW__\xFD[a\x1Bw\x82a!6V[_` \x82\x84\x03\x12\x15a!{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\x14a\x1BwW__\xFD[____``\x85\x87\x03\x12\x15a!\xB1W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a!\xC7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a!\xD7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a!\xEDW__\xFD[\x87` \x82\x84\x01\x01\x11\x15a!\xFEW__\xFD[` \x91\x82\x01\x95P\x93P\x85\x015\x91Pa\"\x18`@\x86\x01a!6V[\x90P\x92\x95\x91\x94P\x92PV[_` \x82\x84\x03\x12\x15a\"3W__\xFD[\x815\x80\x15\x15\x81\x14a\x1BwW__\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`\x12`\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`\x11`\x04R`$_\xFD[_\x82a\"\xAAWa\"\xAAa\"BV[P\x04\x90V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x02\x90\x81\x16\x90\x81\x81\x14a\"\xD2Wa\"\xD2a\"oV[P\x92\x91PPV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x03\xA9Wa\x03\xA9a\"oV[_\x82a#\x07Wa#\x07a\"BV[P\x06\x90V[\x81\x81\x03\x81\x81\x11\x15a\x03\xA9Wa\x03\xA9a\"oV[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x03\xA9Wa\x03\xA9a\"oV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x03\xA9Wa\x03\xA9a\"oV[\x80\x82\x01\x80\x82\x11\x15a\x03\xA9Wa\x03\xA9a\"oV[\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[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x03\xA9Wa\x03\xA9a\"oV[`\x01\x81[`\x01\x84\x11\x15a\x1BVW\x80\x85\x04\x81\x11\x15a#\xCEWa#\xCEa\"oV[`\x01\x84\x16\x15a#\xDCW\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a#\xB3V[_\x82a#\xF8WP`\x01a\x03\xA9V[\x81a$\x04WP_a\x03\xA9V[\x81`\x01\x81\x14a$\x1AW`\x02\x81\x14a$$Wa$@V[`\x01\x91PPa\x03\xA9V[`\xFF\x84\x11\x15a$5Wa$5a\"oV[PP`\x01\x82\x1Ba\x03\xA9V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a$cWP\x81\x81\na\x03\xA9V[a$o_\x19\x84\x84a#\xAFV[\x80_\x19\x04\x82\x11\x15a$\x82Wa$\x82a\"oV[\x02\x93\x92PPPV[_a\x1Bw\x83\x83a#\xEAV\xFE\xA2dipfsX\"\x12 e\x7F\xB9\xDBv0*\xD1\x86\x12>\xAC\x9B\xAC\xE1Wv\x19\xC6t~j\xB9z\x11q\x9FYF\r\x92^dsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `AuthorizationRequirementChanged(bool)` and selector `0xd813b248d49c8bf08be2b6947126da6763df310beed7bea97756456c5727419a`. +```solidity +event AuthorizationRequirementChanged(bool newStatus); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct AuthorizationRequirementChanged { + #[allow(missing_docs)] + pub newStatus: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for AuthorizationRequirementChanged { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "AuthorizationRequirementChanged(bool)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 216u8, 19u8, 178u8, 72u8, 212u8, 156u8, 139u8, 240u8, 139u8, 226u8, + 182u8, 148u8, 113u8, 38u8, 218u8, 103u8, 99u8, 223u8, 49u8, 11u8, 238u8, + 215u8, 190u8, 169u8, 119u8, 86u8, 69u8, 108u8, 87u8, 39u8, 65u8, 154u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { newStatus: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.newStatus, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 AuthorizationRequirementChanged { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&AuthorizationRequirementChanged> + for alloy_sol_types::private::LogData { + #[inline] + fn from( + this: &AuthorizationRequirementChanged, + ) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `Genesis(uint256)` and selector `0x2381d16925551c2fb1a5edfcf4fce2f6d085e1f85f4b88340c09c9d191f9d4e9`. +```solidity +event Genesis(uint256 blockHeight); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct Genesis { + #[allow(missing_docs)] + pub blockHeight: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Genesis { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "Genesis(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 35u8, 129u8, 209u8, 105u8, 37u8, 85u8, 28u8, 47u8, 177u8, 165u8, 237u8, + 252u8, 244u8, 252u8, 226u8, 246u8, 208u8, 133u8, 225u8, 248u8, 95u8, + 75u8, 136u8, 52u8, 12u8, 9u8, 201u8, 209u8, 145u8, 249u8, 212u8, 233u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { blockHeight: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.blockHeight), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 Genesis { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&Genesis> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &Genesis) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for OwnershipTransferred { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + 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, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + previousOwner: topics.1, + newOwner: topics.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return 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) -> ::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() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.previousOwner, + ); + out[2usize] = ::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(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `ProofLengthChanged(uint256)` and selector `0x3e9f904d8cf11753c79b67c8259c582056d4a7d8af120f81257a59eeb8824b96`. +```solidity +event ProofLengthChanged(uint256 newLength); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct ProofLengthChanged { + #[allow(missing_docs)] + pub newLength: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for ProofLengthChanged { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "ProofLengthChanged(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 62u8, 159u8, 144u8, 77u8, 140u8, 241u8, 23u8, 83u8, 199u8, 155u8, 103u8, + 200u8, 37u8, 156u8, 88u8, 32u8, 86u8, 212u8, 167u8, 216u8, 175u8, 18u8, + 15u8, 129u8, 37u8, 122u8, 89u8, 238u8, 184u8, 130u8, 75u8, 150u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { newLength: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.newLength), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 ProofLengthChanged { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&ProofLengthChanged> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &ProofLengthChanged) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `Retarget(uint256,uint256)` and selector `0xa282ee798b132f9dc11e06cd4d8e767e562be8709602ca14fea7ab3392acbdab`. +```solidity +event Retarget(uint256 oldDifficulty, uint256 newDifficulty); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct Retarget { + #[allow(missing_docs)] + pub oldDifficulty: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub newDifficulty: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for Retarget { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "Retarget(uint256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 162u8, 130u8, 238u8, 121u8, 139u8, 19u8, 47u8, 157u8, 193u8, 30u8, 6u8, + 205u8, 77u8, 142u8, 118u8, 126u8, 86u8, 43u8, 232u8, 112u8, 150u8, 2u8, + 202u8, 20u8, 254u8, 167u8, 171u8, 51u8, 146u8, 172u8, 189u8, 171u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + oldDifficulty: data.0, + newDifficulty: data.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.oldDifficulty), + as alloy_sol_types::SolType>::tokenize(&self.newDifficulty), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 Retarget { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&Retarget> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &Retarget) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `SubmitterAuthorized(address)` and selector `0xd53649b492f738bb59d6825099b5955073efda0bf9e3a7ad20da22e110122e29`. +```solidity +event SubmitterAuthorized(address submitter); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct SubmitterAuthorized { + #[allow(missing_docs)] + pub submitter: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for SubmitterAuthorized { + type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "SubmitterAuthorized(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 213u8, 54u8, 73u8, 180u8, 146u8, 247u8, 56u8, 187u8, 89u8, 214u8, 130u8, + 80u8, 153u8, 181u8, 149u8, 80u8, 115u8, 239u8, 218u8, 11u8, 249u8, 227u8, + 167u8, 173u8, 32u8, 218u8, 34u8, 225u8, 16u8, 18u8, 46u8, 41u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { submitter: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.submitter, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 SubmitterAuthorized { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&SubmitterAuthorized> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &SubmitterAuthorized) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `SubmitterDeauthorized(address)` and selector `0x7498b96beeabea5ad3139f1a2861a03e480034254e36b10aae2e6e42ad7b4b68`. +```solidity +event SubmitterDeauthorized(address submitter); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct SubmitterDeauthorized { + #[allow(missing_docs)] + pub submitter: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for SubmitterDeauthorized { + type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "SubmitterDeauthorized(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 116u8, 152u8, 185u8, 107u8, 238u8, 171u8, 234u8, 90u8, 211u8, 19u8, + 159u8, 26u8, 40u8, 97u8, 160u8, 62u8, 72u8, 0u8, 52u8, 37u8, 78u8, 54u8, + 177u8, 10u8, 174u8, 46u8, 110u8, 66u8, 173u8, 123u8, 75u8, 104u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { submitter: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.submitter, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 SubmitterDeauthorized { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&SubmitterDeauthorized> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &SubmitterDeauthorized) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `authorizationRequired()` and selector `0x95410d2b`. +```solidity +function authorizationRequired() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct authorizationRequiredCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`authorizationRequired()`](authorizationRequiredCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct authorizationRequiredReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: authorizationRequiredCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for authorizationRequiredCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: authorizationRequiredReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for authorizationRequiredReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for authorizationRequiredCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "authorizationRequired()"; + const SELECTOR: [u8; 4] = [149u8, 65u8, 13u8, 43u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: authorizationRequiredReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: authorizationRequiredReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `authorize(address)` and selector `0xb6a5d7de`. +```solidity +function authorize(address submitter) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct authorizeCall { + #[allow(missing_docs)] + pub submitter: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`authorize(address)`](authorizeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct authorizeReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: authorizeCall) -> Self { + (value.submitter,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for authorizeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { submitter: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: authorizeReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for authorizeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl authorizeReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for authorizeCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = authorizeReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "authorize(address)"; + const SELECTOR: [u8; 4] = [182u8, 165u8, 215u8, 222u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.submitter, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + authorizeReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `currentEpoch()` and selector `0x76671808`. +```solidity +function currentEpoch() external view returns (uint64); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct currentEpochCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`currentEpoch()`](currentEpochCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct currentEpochReturn { + #[allow(missing_docs)] + pub _0: u64, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: currentEpochCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for currentEpochCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (u64,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: currentEpochReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for currentEpochReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for currentEpochCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = u64; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "currentEpoch()"; + const SELECTOR: [u8; 4] = [118u8, 103u8, 24u8, 8u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: currentEpochReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: currentEpochReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `deauthorize(address)` and selector `0x27c97fa5`. +```solidity +function deauthorize(address submitter) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct deauthorizeCall { + #[allow(missing_docs)] + pub submitter: alloy::sol_types::private::Address, + } + ///Container type for the return parameters of the [`deauthorize(address)`](deauthorizeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct deauthorizeReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: deauthorizeCall) -> Self { + (value.submitter,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for deauthorizeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { submitter: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: deauthorizeReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for deauthorizeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl deauthorizeReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for deauthorizeCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = deauthorizeReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "deauthorize(address)"; + const SELECTOR: [u8; 4] = [39u8, 201u8, 127u8, 165u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.submitter, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + deauthorizeReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `genesis(bytes,uint256,uint64)` and selector `0x4ca49f51`. +```solidity +function genesis(bytes memory genesisHeader, uint256 genesisHeight, uint64 genesisProofLength) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct genesisCall { + #[allow(missing_docs)] + pub genesisHeader: alloy::sol_types::private::Bytes, + #[allow(missing_docs)] + pub genesisHeight: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub genesisProofLength: u64, + } + ///Container type for the return parameters of the [`genesis(bytes,uint256,uint64)`](genesisCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct genesisReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Bytes, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<64>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Bytes, + alloy::sol_types::private::primitives::aliases::U256, + u64, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: genesisCall) -> Self { + (value.genesisHeader, value.genesisHeight, value.genesisProofLength) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for genesisCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + genesisHeader: tuple.0, + genesisHeight: tuple.1, + genesisProofLength: tuple.2, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: genesisReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for genesisReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl genesisReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for genesisCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Bytes, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<64>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = genesisReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "genesis(bytes,uint256,uint64)"; + const SELECTOR: [u8; 4] = [76u8, 164u8, 159u8, 81u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.genesisHeader, + ), + as alloy_sol_types::SolType>::tokenize(&self.genesisHeight), + as alloy_sol_types::SolType>::tokenize(&self.genesisProofLength), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + genesisReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `genesisEpoch()` and selector `0xb70e6be6`. +```solidity +function genesisEpoch() external view returns (uint64); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct genesisEpochCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`genesisEpoch()`](genesisEpochCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct genesisEpochReturn { + #[allow(missing_docs)] + pub _0: u64, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: genesisEpochCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for genesisEpochCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (u64,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: genesisEpochReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for genesisEpochReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for genesisEpochCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = u64; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "genesisEpoch()"; + const SELECTOR: [u8; 4] = [183u8, 14u8, 107u8, 230u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: genesisEpochReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: genesisEpochReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `getBlockDifficulty(uint256)` and selector `0x06a27422`. +```solidity +function getBlockDifficulty(uint256 blockNumber) external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getBlockDifficultyCall { + #[allow(missing_docs)] + pub blockNumber: alloy::sol_types::private::primitives::aliases::U256, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`getBlockDifficulty(uint256)`](getBlockDifficultyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getBlockDifficultyReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getBlockDifficultyCall) -> Self { + (value.blockNumber,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getBlockDifficultyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { blockNumber: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getBlockDifficultyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getBlockDifficultyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getBlockDifficultyCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getBlockDifficulty(uint256)"; + const SELECTOR: [u8; 4] = [6u8, 162u8, 116u8, 34u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.blockNumber), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: getBlockDifficultyReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: getBlockDifficultyReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `getCurrentAndPrevEpochDifficulty()` and selector `0x3a1b77b0`. +```solidity +function getCurrentAndPrevEpochDifficulty() external view returns (uint256 current, uint256 previous); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getCurrentAndPrevEpochDifficultyCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`getCurrentAndPrevEpochDifficulty()`](getCurrentAndPrevEpochDifficultyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getCurrentAndPrevEpochDifficultyReturn { + #[allow(missing_docs)] + pub current: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub previous: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getCurrentAndPrevEpochDifficultyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getCurrentAndPrevEpochDifficultyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getCurrentAndPrevEpochDifficultyReturn) -> Self { + (value.current, value.previous) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getCurrentAndPrevEpochDifficultyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + current: tuple.0, + previous: tuple.1, + } + } + } + } + impl getCurrentAndPrevEpochDifficultyReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + ( + as alloy_sol_types::SolType>::tokenize(&self.current), + as alloy_sol_types::SolType>::tokenize(&self.previous), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getCurrentAndPrevEpochDifficultyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = getCurrentAndPrevEpochDifficultyReturn; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getCurrentAndPrevEpochDifficulty()"; + const SELECTOR: [u8; 4] = [58u8, 27u8, 119u8, 176u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + getCurrentAndPrevEpochDifficultyReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `getCurrentEpochDifficulty()` and selector `0x113764be`. +```solidity +function getCurrentEpochDifficulty() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getCurrentEpochDifficultyCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`getCurrentEpochDifficulty()`](getCurrentEpochDifficultyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getCurrentEpochDifficultyReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getCurrentEpochDifficultyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getCurrentEpochDifficultyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getCurrentEpochDifficultyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getCurrentEpochDifficultyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getCurrentEpochDifficultyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getCurrentEpochDifficulty()"; + const SELECTOR: [u8; 4] = [17u8, 55u8, 100u8, 190u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: getCurrentEpochDifficultyReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: getCurrentEpochDifficultyReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `getEpochDifficulty(uint256)` and selector `0x620414e6`. +```solidity +function getEpochDifficulty(uint256 epochNumber) external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getEpochDifficultyCall { + #[allow(missing_docs)] + pub epochNumber: alloy::sol_types::private::primitives::aliases::U256, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`getEpochDifficulty(uint256)`](getEpochDifficultyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getEpochDifficultyReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getEpochDifficultyCall) -> Self { + (value.epochNumber,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getEpochDifficultyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { epochNumber: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getEpochDifficultyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getEpochDifficultyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getEpochDifficultyCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getEpochDifficulty(uint256)"; + const SELECTOR: [u8; 4] = [98u8, 4u8, 20u8, 230u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.epochNumber), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: getEpochDifficultyReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: getEpochDifficultyReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `getPrevEpochDifficulty()` and selector `0x2b97be24`. +```solidity +function getPrevEpochDifficulty() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getPrevEpochDifficultyCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`getPrevEpochDifficulty()`](getPrevEpochDifficultyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getPrevEpochDifficultyReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getPrevEpochDifficultyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getPrevEpochDifficultyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getPrevEpochDifficultyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getPrevEpochDifficultyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getPrevEpochDifficultyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getPrevEpochDifficulty()"; + const SELECTOR: [u8; 4] = [43u8, 151u8, 190u8, 36u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: getPrevEpochDifficultyReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: getPrevEpochDifficultyReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `getRelayRange()` and selector `0x10b76ed8`. +```solidity +function getRelayRange() external view returns (uint256 relayGenesis, uint256 currentEpochEnd); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getRelayRangeCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`getRelayRange()`](getRelayRangeCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getRelayRangeReturn { + #[allow(missing_docs)] + pub relayGenesis: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub currentEpochEnd: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: getRelayRangeCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for getRelayRangeCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: getRelayRangeReturn) -> Self { + (value.relayGenesis, value.currentEpochEnd) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for getRelayRangeReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + relayGenesis: tuple.0, + currentEpochEnd: tuple.1, + } + } + } + } + impl getRelayRangeReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.relayGenesis), + as alloy_sol_types::SolType>::tokenize(&self.currentEpochEnd), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getRelayRangeCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = getRelayRangeReturn; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getRelayRange()"; + const SELECTOR: [u8; 4] = [16u8, 183u8, 110u8, 216u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + getRelayRangeReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `isAuthorized(address)` and selector `0xfe9fbb80`. +```solidity +function isAuthorized(address) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isAuthorizedCall(pub alloy::sol_types::private::Address); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`isAuthorized(address)`](isAuthorizedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isAuthorizedReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: isAuthorizedCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for isAuthorizedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: isAuthorizedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for isAuthorizedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isAuthorizedCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isAuthorized(address)"; + const SELECTOR: [u8; 4] = [254u8, 159u8, 187u8, 128u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.0, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isAuthorizedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isAuthorizedReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ownerCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ownerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ownerReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ownerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for ownerCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "owner()"; + const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: ownerReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `proofLength()` and selector `0xf5619fda`. +```solidity +function proofLength() external view returns (uint64); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proofLengthCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`proofLength()`](proofLengthCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proofLengthReturn { + #[allow(missing_docs)] + pub _0: u64, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proofLengthCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proofLengthCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (u64,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: proofLengthReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for proofLengthReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for proofLengthCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = u64; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "proofLength()"; + const SELECTOR: [u8; 4] = [245u8, 97u8, 159u8, 218u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: proofLengthReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: proofLengthReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `ready()` and selector `0x6defbf80`. +```solidity +function ready() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct readyCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`ready()`](readyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct readyReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: readyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for readyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: readyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for readyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for readyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ready()"; + const SELECTOR: [u8; 4] = [109u8, 239u8, 191u8, 128u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: readyReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: readyReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: renounceOwnershipCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for renounceOwnershipCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: renounceOwnershipReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for renounceOwnershipReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl renounceOwnershipReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for renounceOwnershipCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = renounceOwnershipReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "renounceOwnership()"; + const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8]; + #[inline] + fn new<'a>( + tuple: 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 { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `retarget(bytes)` and selector `0x7ca5b1dd`. +```solidity +function retarget(bytes memory headers) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct retargetCall { + #[allow(missing_docs)] + pub headers: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`retarget(bytes)`](retargetCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct retargetReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: retargetCall) -> Self { + (value.headers,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for retargetCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { headers: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: retargetReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for retargetReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl retargetReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for retargetCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Bytes,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = retargetReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "retarget(bytes)"; + const SELECTOR: [u8; 4] = [124u8, 165u8, 177u8, 221u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.headers, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + retargetReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `setAuthorizationStatus(bool)` and selector `0xeb8695ef`. +```solidity +function setAuthorizationStatus(bool status) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setAuthorizationStatusCall { + #[allow(missing_docs)] + pub status: bool, + } + ///Container type for the return parameters of the [`setAuthorizationStatus(bool)`](setAuthorizationStatusCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setAuthorizationStatusReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: setAuthorizationStatusCall) -> Self { + (value.status,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for setAuthorizationStatusCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { status: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: setAuthorizationStatusReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for setAuthorizationStatusReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setAuthorizationStatusReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setAuthorizationStatusCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Bool,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setAuthorizationStatusReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setAuthorizationStatus(bool)"; + const SELECTOR: [u8; 4] = [235u8, 134u8, 149u8, 239u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.status, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setAuthorizationStatusReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `setProofLength(uint64)` and selector `0x19c9aa32`. +```solidity +function setProofLength(uint64 newLength) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setProofLengthCall { + #[allow(missing_docs)] + pub newLength: u64, + } + ///Container type for the return parameters of the [`setProofLength(uint64)`](setProofLengthCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setProofLengthReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (u64,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setProofLengthCall) -> Self { + (value.newLength,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setProofLengthCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { newLength: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: setProofLengthReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for setProofLengthReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setProofLengthReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setProofLengthCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<64>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setProofLengthReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setProofLength(uint64)"; + const SELECTOR: [u8; 4] = [25u8, 201u8, 170u8, 50u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.newLength), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setProofLengthReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: transferOwnershipCall) -> Self { + (value.newOwner,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for transferOwnershipCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { newOwner: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: transferOwnershipReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for transferOwnershipReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl transferOwnershipReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for transferOwnershipCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = transferOwnershipReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transferOwnership(address)"; + const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::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 { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `validateChain(bytes)` and selector `0x189179a3`. +```solidity +function validateChain(bytes memory headers) external view returns (uint256 startingHeaderTimestamp, uint256 headerCount); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct validateChainCall { + #[allow(missing_docs)] + pub headers: alloy::sol_types::private::Bytes, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`validateChain(bytes)`](validateChainCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct validateChainReturn { + #[allow(missing_docs)] + pub startingHeaderTimestamp: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub headerCount: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: validateChainCall) -> Self { + (value.headers,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for validateChainCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { headers: tuple.0 } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: validateChainReturn) -> Self { + (value.startingHeaderTimestamp, value.headerCount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for validateChainReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + startingHeaderTimestamp: tuple.0, + headerCount: tuple.1, + } + } + } + } + impl validateChainReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize( + &self.startingHeaderTimestamp, + ), + as alloy_sol_types::SolType>::tokenize(&self.headerCount), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for validateChainCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Bytes,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = validateChainReturn; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "validateChain(bytes)"; + const SELECTOR: [u8; 4] = [24u8, 145u8, 121u8, 163u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.headers, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + validateChainReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + ///Container for all the [`LightRelay`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum LightRelayCalls { + #[allow(missing_docs)] + authorizationRequired(authorizationRequiredCall), + #[allow(missing_docs)] + authorize(authorizeCall), + #[allow(missing_docs)] + currentEpoch(currentEpochCall), + #[allow(missing_docs)] + deauthorize(deauthorizeCall), + #[allow(missing_docs)] + genesis(genesisCall), + #[allow(missing_docs)] + genesisEpoch(genesisEpochCall), + #[allow(missing_docs)] + getBlockDifficulty(getBlockDifficultyCall), + #[allow(missing_docs)] + getCurrentAndPrevEpochDifficulty(getCurrentAndPrevEpochDifficultyCall), + #[allow(missing_docs)] + getCurrentEpochDifficulty(getCurrentEpochDifficultyCall), + #[allow(missing_docs)] + getEpochDifficulty(getEpochDifficultyCall), + #[allow(missing_docs)] + getPrevEpochDifficulty(getPrevEpochDifficultyCall), + #[allow(missing_docs)] + getRelayRange(getRelayRangeCall), + #[allow(missing_docs)] + isAuthorized(isAuthorizedCall), + #[allow(missing_docs)] + owner(ownerCall), + #[allow(missing_docs)] + proofLength(proofLengthCall), + #[allow(missing_docs)] + ready(readyCall), + #[allow(missing_docs)] + renounceOwnership(renounceOwnershipCall), + #[allow(missing_docs)] + retarget(retargetCall), + #[allow(missing_docs)] + setAuthorizationStatus(setAuthorizationStatusCall), + #[allow(missing_docs)] + setProofLength(setProofLengthCall), + #[allow(missing_docs)] + transferOwnership(transferOwnershipCall), + #[allow(missing_docs)] + validateChain(validateChainCall), + } + #[automatically_derived] + impl LightRelayCalls { + /// 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, 162u8, 116u8, 34u8], + [16u8, 183u8, 110u8, 216u8], + [17u8, 55u8, 100u8, 190u8], + [24u8, 145u8, 121u8, 163u8], + [25u8, 201u8, 170u8, 50u8], + [39u8, 201u8, 127u8, 165u8], + [43u8, 151u8, 190u8, 36u8], + [58u8, 27u8, 119u8, 176u8], + [76u8, 164u8, 159u8, 81u8], + [98u8, 4u8, 20u8, 230u8], + [109u8, 239u8, 191u8, 128u8], + [113u8, 80u8, 24u8, 166u8], + [118u8, 103u8, 24u8, 8u8], + [124u8, 165u8, 177u8, 221u8], + [141u8, 165u8, 203u8, 91u8], + [149u8, 65u8, 13u8, 43u8], + [182u8, 165u8, 215u8, 222u8], + [183u8, 14u8, 107u8, 230u8], + [235u8, 134u8, 149u8, 239u8], + [242u8, 253u8, 227u8, 139u8], + [245u8, 97u8, 159u8, 218u8], + [254u8, 159u8, 187u8, 128u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for LightRelayCalls { + const NAME: &'static str = "LightRelayCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 22usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::authorizationRequired(_) => { + ::SELECTOR + } + Self::authorize(_) => { + ::SELECTOR + } + Self::currentEpoch(_) => { + ::SELECTOR + } + Self::deauthorize(_) => { + ::SELECTOR + } + Self::genesis(_) => ::SELECTOR, + Self::genesisEpoch(_) => { + ::SELECTOR + } + Self::getBlockDifficulty(_) => { + ::SELECTOR + } + Self::getCurrentAndPrevEpochDifficulty(_) => { + ::SELECTOR + } + Self::getCurrentEpochDifficulty(_) => { + ::SELECTOR + } + Self::getEpochDifficulty(_) => { + ::SELECTOR + } + Self::getPrevEpochDifficulty(_) => { + ::SELECTOR + } + Self::getRelayRange(_) => { + ::SELECTOR + } + Self::isAuthorized(_) => { + ::SELECTOR + } + Self::owner(_) => ::SELECTOR, + Self::proofLength(_) => { + ::SELECTOR + } + Self::ready(_) => ::SELECTOR, + Self::renounceOwnership(_) => { + ::SELECTOR + } + Self::retarget(_) => ::SELECTOR, + Self::setAuthorizationStatus(_) => { + ::SELECTOR + } + Self::setProofLength(_) => { + ::SELECTOR + } + Self::transferOwnership(_) => { + ::SELECTOR + } + Self::validateChain(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn getBlockDifficulty( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(LightRelayCalls::getBlockDifficulty) + } + getBlockDifficulty + }, + { + fn getRelayRange( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(LightRelayCalls::getRelayRange) + } + getRelayRange + }, + { + fn getCurrentEpochDifficulty( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(LightRelayCalls::getCurrentEpochDifficulty) + } + getCurrentEpochDifficulty + }, + { + fn validateChain( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(LightRelayCalls::validateChain) + } + validateChain + }, + { + fn setProofLength( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(LightRelayCalls::setProofLength) + } + setProofLength + }, + { + fn deauthorize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(LightRelayCalls::deauthorize) + } + deauthorize + }, + { + fn getPrevEpochDifficulty( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(LightRelayCalls::getPrevEpochDifficulty) + } + getPrevEpochDifficulty + }, + { + fn getCurrentAndPrevEpochDifficulty( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(LightRelayCalls::getCurrentAndPrevEpochDifficulty) + } + getCurrentAndPrevEpochDifficulty + }, + { + fn genesis(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(LightRelayCalls::genesis) + } + genesis + }, + { + fn getEpochDifficulty( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(LightRelayCalls::getEpochDifficulty) + } + getEpochDifficulty + }, + { + fn ready(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(LightRelayCalls::ready) + } + ready + }, + { + fn renounceOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(LightRelayCalls::renounceOwnership) + } + renounceOwnership + }, + { + fn currentEpoch( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(LightRelayCalls::currentEpoch) + } + currentEpoch + }, + { + fn retarget( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(LightRelayCalls::retarget) + } + retarget + }, + { + fn owner(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(LightRelayCalls::owner) + } + owner + }, + { + fn authorizationRequired( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(LightRelayCalls::authorizationRequired) + } + authorizationRequired + }, + { + fn authorize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(LightRelayCalls::authorize) + } + authorize + }, + { + fn genesisEpoch( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(LightRelayCalls::genesisEpoch) + } + genesisEpoch + }, + { + fn setAuthorizationStatus( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(LightRelayCalls::setAuthorizationStatus) + } + setAuthorizationStatus + }, + { + fn transferOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(LightRelayCalls::transferOwnership) + } + transferOwnership + }, + { + fn proofLength( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(LightRelayCalls::proofLength) + } + proofLength + }, + { + fn isAuthorized( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(LightRelayCalls::isAuthorized) + } + isAuthorized + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn getBlockDifficulty( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(LightRelayCalls::getBlockDifficulty) + } + getBlockDifficulty + }, + { + fn getRelayRange( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(LightRelayCalls::getRelayRange) + } + getRelayRange + }, + { + fn getCurrentEpochDifficulty( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(LightRelayCalls::getCurrentEpochDifficulty) + } + getCurrentEpochDifficulty + }, + { + fn validateChain( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(LightRelayCalls::validateChain) + } + validateChain + }, + { + fn setProofLength( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(LightRelayCalls::setProofLength) + } + setProofLength + }, + { + fn deauthorize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(LightRelayCalls::deauthorize) + } + deauthorize + }, + { + fn getPrevEpochDifficulty( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(LightRelayCalls::getPrevEpochDifficulty) + } + getPrevEpochDifficulty + }, + { + fn getCurrentAndPrevEpochDifficulty( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(LightRelayCalls::getCurrentAndPrevEpochDifficulty) + } + getCurrentAndPrevEpochDifficulty + }, + { + fn genesis(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(LightRelayCalls::genesis) + } + genesis + }, + { + fn getEpochDifficulty( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(LightRelayCalls::getEpochDifficulty) + } + getEpochDifficulty + }, + { + fn ready(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(LightRelayCalls::ready) + } + ready + }, + { + fn renounceOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(LightRelayCalls::renounceOwnership) + } + renounceOwnership + }, + { + fn currentEpoch( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(LightRelayCalls::currentEpoch) + } + currentEpoch + }, + { + fn retarget( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(LightRelayCalls::retarget) + } + retarget + }, + { + fn owner(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(LightRelayCalls::owner) + } + owner + }, + { + fn authorizationRequired( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(LightRelayCalls::authorizationRequired) + } + authorizationRequired + }, + { + fn authorize( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(LightRelayCalls::authorize) + } + authorize + }, + { + fn genesisEpoch( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(LightRelayCalls::genesisEpoch) + } + genesisEpoch + }, + { + fn setAuthorizationStatus( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(LightRelayCalls::setAuthorizationStatus) + } + setAuthorizationStatus + }, + { + fn transferOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(LightRelayCalls::transferOwnership) + } + transferOwnership + }, + { + fn proofLength( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(LightRelayCalls::proofLength) + } + proofLength + }, + { + fn isAuthorized( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(LightRelayCalls::isAuthorized) + } + isAuthorized + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::authorizationRequired(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::authorize(inner) => { + ::abi_encoded_size(inner) + } + Self::currentEpoch(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::deauthorize(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::genesis(inner) => { + ::abi_encoded_size(inner) + } + Self::genesisEpoch(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getBlockDifficulty(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getCurrentAndPrevEpochDifficulty(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getCurrentEpochDifficulty(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getEpochDifficulty(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getPrevEpochDifficulty(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getRelayRange(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::isAuthorized(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::owner(inner) => { + ::abi_encoded_size(inner) + } + Self::proofLength(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ready(inner) => { + ::abi_encoded_size(inner) + } + Self::renounceOwnership(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::retarget(inner) => { + ::abi_encoded_size(inner) + } + Self::setAuthorizationStatus(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::setProofLength(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::transferOwnership(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::validateChain(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::authorizationRequired(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::authorize(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::currentEpoch(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::deauthorize(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::genesis(inner) => { + ::abi_encode_raw(inner, out) + } + Self::genesisEpoch(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getBlockDifficulty(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getCurrentAndPrevEpochDifficulty(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getCurrentEpochDifficulty(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getEpochDifficulty(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getPrevEpochDifficulty(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getRelayRange(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isAuthorized(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::owner(inner) => { + ::abi_encode_raw(inner, out) + } + Self::proofLength(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ready(inner) => { + ::abi_encode_raw(inner, out) + } + Self::renounceOwnership(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::retarget(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::setAuthorizationStatus(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::setProofLength(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transferOwnership(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::validateChain(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`LightRelay`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum LightRelayEvents { + #[allow(missing_docs)] + AuthorizationRequirementChanged(AuthorizationRequirementChanged), + #[allow(missing_docs)] + Genesis(Genesis), + #[allow(missing_docs)] + OwnershipTransferred(OwnershipTransferred), + #[allow(missing_docs)] + ProofLengthChanged(ProofLengthChanged), + #[allow(missing_docs)] + Retarget(Retarget), + #[allow(missing_docs)] + SubmitterAuthorized(SubmitterAuthorized), + #[allow(missing_docs)] + SubmitterDeauthorized(SubmitterDeauthorized), + } + #[automatically_derived] + impl LightRelayEvents { + /// 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]] = &[ + [ + 35u8, 129u8, 209u8, 105u8, 37u8, 85u8, 28u8, 47u8, 177u8, 165u8, 237u8, + 252u8, 244u8, 252u8, 226u8, 246u8, 208u8, 133u8, 225u8, 248u8, 95u8, + 75u8, 136u8, 52u8, 12u8, 9u8, 201u8, 209u8, 145u8, 249u8, 212u8, 233u8, + ], + [ + 62u8, 159u8, 144u8, 77u8, 140u8, 241u8, 23u8, 83u8, 199u8, 155u8, 103u8, + 200u8, 37u8, 156u8, 88u8, 32u8, 86u8, 212u8, 167u8, 216u8, 175u8, 18u8, + 15u8, 129u8, 37u8, 122u8, 89u8, 238u8, 184u8, 130u8, 75u8, 150u8, + ], + [ + 116u8, 152u8, 185u8, 107u8, 238u8, 171u8, 234u8, 90u8, 211u8, 19u8, + 159u8, 26u8, 40u8, 97u8, 160u8, 62u8, 72u8, 0u8, 52u8, 37u8, 78u8, 54u8, + 177u8, 10u8, 174u8, 46u8, 110u8, 66u8, 173u8, 123u8, 75u8, 104u8, + ], + [ + 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, + ], + [ + 162u8, 130u8, 238u8, 121u8, 139u8, 19u8, 47u8, 157u8, 193u8, 30u8, 6u8, + 205u8, 77u8, 142u8, 118u8, 126u8, 86u8, 43u8, 232u8, 112u8, 150u8, 2u8, + 202u8, 20u8, 254u8, 167u8, 171u8, 51u8, 146u8, 172u8, 189u8, 171u8, + ], + [ + 213u8, 54u8, 73u8, 180u8, 146u8, 247u8, 56u8, 187u8, 89u8, 214u8, 130u8, + 80u8, 153u8, 181u8, 149u8, 80u8, 115u8, 239u8, 218u8, 11u8, 249u8, 227u8, + 167u8, 173u8, 32u8, 218u8, 34u8, 225u8, 16u8, 18u8, 46u8, 41u8, + ], + [ + 216u8, 19u8, 178u8, 72u8, 212u8, 156u8, 139u8, 240u8, 139u8, 226u8, + 182u8, 148u8, 113u8, 38u8, 218u8, 103u8, 99u8, 223u8, 49u8, 11u8, 238u8, + 215u8, 190u8, 169u8, 119u8, 86u8, 69u8, 108u8, 87u8, 39u8, 65u8, 154u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for LightRelayEvents { + const NAME: &'static str = "LightRelayEvents"; + const COUNT: usize = 7usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::AuthorizationRequirementChanged) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Genesis) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::OwnershipTransferred) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::ProofLengthChanged) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::Retarget) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::SubmitterAuthorized) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::SubmitterDeauthorized) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 LightRelayEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::AuthorizationRequirementChanged(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::Genesis(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::OwnershipTransferred(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::ProofLengthChanged(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::Retarget(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::SubmitterAuthorized(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::SubmitterDeauthorized(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::AuthorizationRequirementChanged(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::Genesis(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::OwnershipTransferred(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::ProofLengthChanged(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::Retarget(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::SubmitterAuthorized(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::SubmitterDeauthorized(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`LightRelay`](self) contract instance. + +See the [wrapper's documentation](`LightRelayInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> LightRelayInstance { + LightRelayInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + LightRelayInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + LightRelayInstance::::deploy_builder(provider) + } + /**A [`LightRelay`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`LightRelay`](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 LightRelayInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for LightRelayInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("LightRelayInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > LightRelayInstance { + /**Creates a new wrapper around an on-chain [`LightRelay`](self) contract instance. + +See the [wrapper's documentation](`LightRelayInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 LightRelayInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> LightRelayInstance { + LightRelayInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > LightRelayInstance { + /// 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( + &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 [`authorizationRequired`] function. + pub fn authorizationRequired( + &self, + ) -> alloy_contract::SolCallBuilder<&P, authorizationRequiredCall, N> { + self.call_builder(&authorizationRequiredCall) + } + ///Creates a new call builder for the [`authorize`] function. + pub fn authorize( + &self, + submitter: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, authorizeCall, N> { + self.call_builder(&authorizeCall { submitter }) + } + ///Creates a new call builder for the [`currentEpoch`] function. + pub fn currentEpoch( + &self, + ) -> alloy_contract::SolCallBuilder<&P, currentEpochCall, N> { + self.call_builder(¤tEpochCall) + } + ///Creates a new call builder for the [`deauthorize`] function. + pub fn deauthorize( + &self, + submitter: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, deauthorizeCall, N> { + self.call_builder(&deauthorizeCall { submitter }) + } + ///Creates a new call builder for the [`genesis`] function. + pub fn genesis( + &self, + genesisHeader: alloy::sol_types::private::Bytes, + genesisHeight: alloy::sol_types::private::primitives::aliases::U256, + genesisProofLength: u64, + ) -> alloy_contract::SolCallBuilder<&P, genesisCall, N> { + self.call_builder( + &genesisCall { + genesisHeader, + genesisHeight, + genesisProofLength, + }, + ) + } + ///Creates a new call builder for the [`genesisEpoch`] function. + pub fn genesisEpoch( + &self, + ) -> alloy_contract::SolCallBuilder<&P, genesisEpochCall, N> { + self.call_builder(&genesisEpochCall) + } + ///Creates a new call builder for the [`getBlockDifficulty`] function. + pub fn getBlockDifficulty( + &self, + blockNumber: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, getBlockDifficultyCall, N> { + self.call_builder( + &getBlockDifficultyCall { + blockNumber, + }, + ) + } + ///Creates a new call builder for the [`getCurrentAndPrevEpochDifficulty`] function. + pub fn getCurrentAndPrevEpochDifficulty( + &self, + ) -> alloy_contract::SolCallBuilder< + &P, + getCurrentAndPrevEpochDifficultyCall, + N, + > { + self.call_builder(&getCurrentAndPrevEpochDifficultyCall) + } + ///Creates a new call builder for the [`getCurrentEpochDifficulty`] function. + pub fn getCurrentEpochDifficulty( + &self, + ) -> alloy_contract::SolCallBuilder<&P, getCurrentEpochDifficultyCall, N> { + self.call_builder(&getCurrentEpochDifficultyCall) + } + ///Creates a new call builder for the [`getEpochDifficulty`] function. + pub fn getEpochDifficulty( + &self, + epochNumber: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, getEpochDifficultyCall, N> { + self.call_builder( + &getEpochDifficultyCall { + epochNumber, + }, + ) + } + ///Creates a new call builder for the [`getPrevEpochDifficulty`] function. + pub fn getPrevEpochDifficulty( + &self, + ) -> alloy_contract::SolCallBuilder<&P, getPrevEpochDifficultyCall, N> { + self.call_builder(&getPrevEpochDifficultyCall) + } + ///Creates a new call builder for the [`getRelayRange`] function. + pub fn getRelayRange( + &self, + ) -> alloy_contract::SolCallBuilder<&P, getRelayRangeCall, N> { + self.call_builder(&getRelayRangeCall) + } + ///Creates a new call builder for the [`isAuthorized`] function. + pub fn isAuthorized( + &self, + _0: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isAuthorizedCall, N> { + self.call_builder(&isAuthorizedCall(_0)) + } + ///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 [`proofLength`] function. + pub fn proofLength( + &self, + ) -> alloy_contract::SolCallBuilder<&P, proofLengthCall, N> { + self.call_builder(&proofLengthCall) + } + ///Creates a new call builder for the [`ready`] function. + pub fn ready(&self) -> alloy_contract::SolCallBuilder<&P, readyCall, N> { + self.call_builder(&readyCall) + } + ///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 [`retarget`] function. + pub fn retarget( + &self, + headers: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, retargetCall, N> { + self.call_builder(&retargetCall { headers }) + } + ///Creates a new call builder for the [`setAuthorizationStatus`] function. + pub fn setAuthorizationStatus( + &self, + status: bool, + ) -> alloy_contract::SolCallBuilder<&P, setAuthorizationStatusCall, N> { + self.call_builder( + &setAuthorizationStatusCall { + status, + }, + ) + } + ///Creates a new call builder for the [`setProofLength`] function. + pub fn setProofLength( + &self, + newLength: u64, + ) -> alloy_contract::SolCallBuilder<&P, setProofLengthCall, N> { + self.call_builder(&setProofLengthCall { newLength }) + } + ///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 [`validateChain`] function. + pub fn validateChain( + &self, + headers: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, validateChainCall, N> { + self.call_builder(&validateChainCall { headers }) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > LightRelayInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`AuthorizationRequirementChanged`] event. + pub fn AuthorizationRequirementChanged_filter( + &self, + ) -> alloy_contract::Event<&P, AuthorizationRequirementChanged, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`Genesis`] event. + pub fn Genesis_filter(&self) -> alloy_contract::Event<&P, Genesis, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`OwnershipTransferred`] event. + pub fn OwnershipTransferred_filter( + &self, + ) -> alloy_contract::Event<&P, OwnershipTransferred, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`ProofLengthChanged`] event. + pub fn ProofLengthChanged_filter( + &self, + ) -> alloy_contract::Event<&P, ProofLengthChanged, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`Retarget`] event. + pub fn Retarget_filter(&self) -> alloy_contract::Event<&P, Retarget, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`SubmitterAuthorized`] event. + pub fn SubmitterAuthorized_filter( + &self, + ) -> alloy_contract::Event<&P, SubmitterAuthorized, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`SubmitterDeauthorized`] event. + pub fn SubmitterDeauthorized_filter( + &self, + ) -> alloy_contract::Event<&P, SubmitterDeauthorized, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/market_place.rs b/crates/bindings/src/market_place.rs new file mode 100644 index 000000000..7ec855f89 --- /dev/null +++ b/crates/bindings/src/market_place.rs @@ -0,0 +1,3197 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface MarketPlace { + struct Order { + uint256 offeringAmount; + address offeringToken; + uint256 askingAmount; + address askingToken; + address requesterAddress; + } + + event acceptOrder(uint256 indexed orderId, address indexed who, uint256 buyAmount, uint256 saleAmount); + event placeOrder(uint256 indexed orderId, address indexed requesterAddress, uint256 offeringAmount, address offeringToken, uint256 askingAmount, address askingToken); + event withdrawOrder(uint256 indexed orderId); + + constructor(address erc2771Forwarder); + + function acceptErcErcOrder(uint256 id, uint256 saleAmount) external; + function ercErcOrders(uint256) external view returns (uint256 offeringAmount, address offeringToken, uint256 askingAmount, address askingToken, address requesterAddress); + function getOpenOrders() external view returns (Order[] memory, uint256[] memory); + function getTrustedForwarder() external view returns (address forwarder); + function isTrustedForwarder(address forwarder) external view returns (bool); + function nextOrderId() external view returns (uint256); + function placeErcErcOrder(address sellingToken, uint256 saleAmount, address buyingToken, uint256 buyAmount) external; + function withdrawErcErcOrder(uint256 id) external; +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "erc2771Forwarder", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "acceptErcErcOrder", + "inputs": [ + { + "name": "id", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "saleAmount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "ercErcOrders", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "offeringAmount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "offeringToken", + "type": "address", + "internalType": "address" + }, + { + "name": "askingAmount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "askingToken", + "type": "address", + "internalType": "address" + }, + { + "name": "requesterAddress", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getOpenOrders", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "tuple[]", + "internalType": "struct MarketPlace.Order[]", + "components": [ + { + "name": "offeringAmount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "offeringToken", + "type": "address", + "internalType": "address" + }, + { + "name": "askingAmount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "askingToken", + "type": "address", + "internalType": "address" + }, + { + "name": "requesterAddress", + "type": "address", + "internalType": "address" + } + ] + }, + { + "name": "", + "type": "uint256[]", + "internalType": "uint256[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getTrustedForwarder", + "inputs": [], + "outputs": [ + { + "name": "forwarder", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isTrustedForwarder", + "inputs": [ + { + "name": "forwarder", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "nextOrderId", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "placeErcErcOrder", + "inputs": [ + { + "name": "sellingToken", + "type": "address", + "internalType": "address" + }, + { + "name": "saleAmount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "buyingToken", + "type": "address", + "internalType": "address" + }, + { + "name": "buyAmount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "withdrawErcErcOrder", + "inputs": [ + { + "name": "id", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "event", + "name": "acceptOrder", + "inputs": [ + { + "name": "orderId", + "type": "uint256", + "indexed": true, + "internalType": "uint256" + }, + { + "name": "who", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "buyAmount", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "saleAmount", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "placeOrder", + "inputs": [ + { + "name": "orderId", + "type": "uint256", + "indexed": true, + "internalType": "uint256" + }, + { + "name": "requesterAddress", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "offeringAmount", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "offeringToken", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "askingAmount", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "askingToken", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "withdrawOrder", + "inputs": [ + { + "name": "orderId", + "type": "uint256", + "indexed": true, + "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 MarketPlace { + use super::*; + use alloy::sol_types as 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[P`@Qa\x10=8\x03\x80a\x10=\x839\x81\x01`@\x81\x90R`+\x91`JV[_\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x83\x16\x17\x90UP`uV[_` \x82\x84\x03\x12\x15`YW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14`nW__\xFD[\x93\x92PPPV[a\x0F\xBB\x80a\0\x82_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\x85W_5`\xE0\x1C\x80c\\Yh\xBB\x11a\0XW\x80c\\Yh\xBB\x14a\0\xFEW\x80c\xCE\x1B\x81_\x14a\x01zW\x80c\xDB\xE5\xBA\xB5\x14a\x01\x94W\x80c\xF8\x18\x11p\x14a\x01\xAAW__\xFD[\x80c\x04\xBC\x1E{\x14a\0\x89W\x80c\"\xECT\xA0\x14a\0\x9EW\x80c*X\xB30\x14a\0\xB1W\x80cW+l\x05\x14a\0\xCDW[__\xFD[a\0\x9Ca\0\x976`\x04a\x0CAV[a\x01\xBDV[\0[a\0\x9Ca\0\xAC6`\x04a\x0CsV[a\x02\xE7V[a\0\xBA`\x02T\x81V[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\xEEa\0\xDB6`\x04a\x0C\xB4V[_T`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x91\x16\x14\x90V[`@Q\x90\x15\x15\x81R` \x01a\0\xC4V[a\x01Ha\x01\x0C6`\x04a\x0CAV[`\x01` \x81\x90R_\x91\x82R`@\x90\x91 \x80T\x91\x81\x01T`\x02\x82\x01T`\x03\x83\x01T`\x04\x90\x93\x01T`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x93\x91\x92\x91\x82\x16\x91\x16\x85V[`@\x80Q\x95\x86R`\x01`\x01`\xA0\x1B\x03\x94\x85\x16` \x87\x01R\x85\x01\x92\x90\x92R\x82\x16``\x84\x01R\x16`\x80\x82\x01R`\xA0\x01a\0\xC4V[_T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\0\xC4V[a\x01\x9Ca\x04rV[`@Qa\0\xC4\x92\x91\x90a\r\x07V[a\0\x9Ca\x01\xB86`\x04a\r\xA9V[a\x06>V[_\x81\x81R`\x01` \x81\x81R`@\x92\x83\x90 \x83Q`\xA0\x81\x01\x85R\x81T\x81R\x92\x81\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x92\x84\x01\x92\x90\x92R`\x02\x81\x01T\x93\x83\x01\x93\x90\x93R`\x03\x83\x01T\x81\x16``\x83\x01R`\x04\x90\x92\x01T\x90\x91\x16`\x80\x82\x01Ra\x02\x1Ea\x07\xE8V[`\x01`\x01`\xA0\x1B\x03\x16\x81`\x80\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x14a\x02>W__\xFD[a\x02`a\x02Ia\x07\xE8V[\x82Q` \x84\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x91\x90a\x088V[_\x82\x81R`\x01` \x81\x90R`@\x80\x83 \x83\x81U\x91\x82\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\x90\x81\x16\x90\x91U`\x02\x83\x01\x84\x90U`\x03\x83\x01\x80T\x82\x16\x90U`\x04\x90\x92\x01\x80T\x90\x92\x16\x90\x91UQ\x83\x91\x7F\xFBy\x1B\x0B\x90\xB7Jb\xA7\xD09X3b\xB4\xBE$K\x07\"rb##\x94\xE9#\xC1d\x88\xED1\x91\xA2PPV[`\x01`\x01`\xA0\x1B\x03\x84\x16a\x02\xF9W__\xFD[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x03\x0BW__\xFD[a\x03(a\x03\x16a\x07\xE8V[`\x01`\x01`\xA0\x1B\x03\x86\x16\x900\x86a\t\x04V[`\x02\x80T_\x91\x82a\x038\x83a\r\xF6V[\x91\x90PU\x90P_`@Q\x80`\xA0\x01`@R\x80\x86\x81R` \x01\x87`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x84\x81R` \x01\x85`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a\x03|a\x07\xE8V[`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x90\x91R_\x84\x81R`\x01` \x81\x81R`@\x92\x83\x90 \x85Q\x80\x82U\x91\x86\x01Q\x92\x81\x01\x80T\x84\x87\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\x84\x87\x01Q`\x02\x83\x01\x81\x90U``\x88\x01Q`\x03\x84\x01\x80T\x82\x8A\x16\x90\x85\x16\x17\x90U`\x80\x89\x01Q`\x04\x90\x94\x01\x80T\x94\x90\x98\x16\x93\x90\x92\x16\x83\x17\x90\x96U\x93Q\x95\x96P\x94\x87\x94\x7F\xC4\x04j0\\Y\xED\xB2G.c\x8A(\xCE\xDB\x16V<\x8A\xA0\xA4\xF8\xFA\xFF\xCA\xEF\x1CC\xA2o\x88l\x94a\x04b\x94\x92\x93\x84R`\x01`\x01`\xA0\x1B\x03\x92\x83\x16` \x85\x01R`@\x84\x01\x91\x90\x91R\x16``\x82\x01R`\x80\x01\x90V[`@Q\x80\x91\x03\x90\xA3PPPPPPV[``\x80_\x80[`\x02T\x81\x10\x15a\x04\xABW_\x81\x81R`\x01` R`@\x90 T\x15a\x04\xA3W\x81a\x04\x9F\x81a\r\xF6V[\x92PP[`\x01\x01a\x04xV[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x04\xC6Wa\x04\xC6a\x0E\x0EV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x05\x1DW\x81` \x01[`@\x80Q`\xA0\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x92\x82\x01\x81\x90R``\x82\x01\x81\x90R`\x80\x82\x01R\x82R_\x19\x90\x92\x01\x91\x01\x81a\x04\xE4W\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x05:Wa\x05:a\x0E\x0EV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x05cW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x02T\x81\x10\x15a\x062W_\x81\x81R`\x01` R`@\x90 T\x15a\x06*W_\x81\x81R`\x01` \x81\x81R`@\x92\x83\x90 \x83Q`\xA0\x81\x01\x85R\x81T\x81R\x92\x81\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x92\x84\x01\x92\x90\x92R`\x02\x81\x01T\x93\x83\x01\x93\x90\x93R`\x03\x83\x01T\x81\x16``\x83\x01R`\x04\x90\x92\x01T\x90\x91\x16`\x80\x82\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x05\xF3Wa\x05\xF3a\x0E;V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x06\x11Wa\x06\x11a\x0E;V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x06&\x81a\r\xF6V[\x92PP[`\x01\x01a\x05iV[P\x91\x95\x90\x94P\x92PPPV[_\x82\x81R`\x01` \x81\x81R`@\x92\x83\x90 \x83Q`\xA0\x81\x01\x85R\x81T\x81R\x92\x81\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x92\x84\x01\x92\x90\x92R`\x02\x81\x01T\x93\x83\x01\x93\x90\x93R`\x03\x83\x01T\x81\x16``\x83\x01R`\x04\x90\x92\x01T\x90\x91\x16`\x80\x82\x01\x81\x90Ra\x06\xA1W__\xFD[\x80`@\x01Q\x82\x11\x15a\x06\xB1W__\xFD[`@\x81\x01Q\x81Q_\x91\x90a\x06\xC5\x90\x85a\x0EhV[a\x06\xCF\x91\x90a\x0E\x85V[\x90P_\x83\x11a\x06\xE0Wa\x06\xE0a\x0E\xBDV[_\x81\x11a\x06\xEFWa\x06\xEFa\x0E\xBDV[\x81Q\x81\x11\x15a\x07\0Wa\x07\0a\x0E\xBDV[_\x84\x81R`\x01` R`@\x81 \x80T\x83\x92\x90a\x07\x1D\x90\x84\x90a\x0E\xEAV[\x90\x91UPP_\x84\x81R`\x01` R`@\x81 `\x02\x01\x80T\x85\x92\x90a\x07B\x90\x84\x90a\x0E\xEAV[\x90\x91UPa\x07n\x90Pa\x07Sa\x07\xE8V[`\x80\x84\x01Q``\x85\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x91\x90\x86a\t\x04V[a\x07\x8Ea\x07ya\x07\xE8V[` \x84\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x90\x83a\x088V[a\x07\x96a\x07\xE8V[`\x01`\x01`\xA0\x1B\x03\x16\x84\x7F\x01\x1F\xCFo\xC5?\xC7\x99q\xC9\xE9?\x9A\xDC\xEDl\x1F'#\x17{K\x92\xBE\x86\x10+\x05X\xFB\xB08\x83\x86`@Qa\x07\xDA\x92\x91\x90\x91\x82R` \x82\x01R`@\x01\x90V[`@Q\x80\x91\x03\x90\xA3PPPPV[_`\x146\x10\x80\x15\x90a\x08\x03WP_T`\x01`\x01`\xA0\x1B\x03\x163\x14[\x15a\x083WP\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xEC6\x015``\x1C\x90V[P3\x90V[`@Q`\x01`\x01`\xA0\x1B\x03\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x08\xFF\x90\x84\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\x90`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\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\t[V[PPPV[`@Q`\x01`\x01`\xA0\x1B\x03\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\tU\x90\x85\x90\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\x90`\x84\x01a\x08}V[PPPPV[_a\t\xAF\x82`@Q\x80`@\x01`@R\x80` \x81R` \x01\x7FSafeERC20: low-level call failed\x81RP\x85`\x01`\x01`\xA0\x1B\x03\x16a\n^\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x08\xFFW\x80\x80` \x01\x90Q\x81\x01\x90a\t\xCD\x91\x90a\x0E\xFDV[a\x08\xFFW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x01[`@Q\x80\x91\x03\x90\xFD[``a\nl\x84\x84_\x85a\nvV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x0B\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`&`$\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\nUV[`\x01`\x01`\xA0\x1B\x03\x85\x16;a\x0ByW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\nUV[__\x86`\x01`\x01`\xA0\x1B\x03\x16\x85\x87`@Qa\x0B\x94\x91\x90a\x0F\x1CV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x0B\xCEW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x0B\xD3V[``\x91P[P\x91P\x91Pa\x0B\xE3\x82\x82\x86a\x0B\xEEV[\x97\x96PPPPPPPV[``\x83\x15a\x0B\xFDWP\x81a\noV[\x82Q\x15a\x0C\rW\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\nU\x91\x90a\x0F2V[_` \x82\x84\x03\x12\x15a\x0CQW__\xFD[P5\x91\x90PV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0CnW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0C\x86W__\xFD[a\x0C\x8F\x85a\x0CXV[\x93P` \x85\x015\x92Pa\x0C\xA4`@\x86\x01a\x0CXV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[_` \x82\x84\x03\x12\x15a\x0C\xC4W__\xFD[a\no\x82a\x0CXV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x0C\xFDW\x81Q\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x0C\xDFV[P\x93\x94\x93PPPPV[`@\x80\x82R\x83Q\x90\x82\x01\x81\x90R_\x90` \x85\x01\x90``\x84\x01\x90\x83[\x81\x81\x10\x15a\r\x8BW\x83Q\x80Q\x84R`\x01`\x01`\xA0\x1B\x03` \x82\x01Q\x16` \x85\x01R`@\x81\x01Q`@\x85\x01R`\x01`\x01`\xA0\x1B\x03``\x82\x01Q\x16``\x85\x01R`\x01`\x01`\xA0\x1B\x03`\x80\x82\x01Q\x16`\x80\x85\x01RP`\xA0\x83\x01\x92P` \x84\x01\x93P`\x01\x81\x01\x90Pa\r\"V[PP\x83\x81\x03` \x85\x01Ra\r\x9F\x81\x86a\x0C\xCDV[\x96\x95PPPPPPV[__`@\x83\x85\x03\x12\x15a\r\xBAW__\xFD[PP\x805\x92` \x90\x91\x015\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`\x11`\x04R`$_\xFD[__\x19\x82\x03a\x0E\x07Wa\x0E\x07a\r\xC9V[P`\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`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[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x0E\x7FWa\x0E\x7Fa\r\xC9V[\x92\x91PPV[_\x82a\x0E\xB8W\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[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`\x01`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x0E\x7FWa\x0E\x7Fa\r\xC9V[_` \x82\x84\x03\x12\x15a\x0F\rW__\xFD[\x81Q\x80\x15\x15\x81\x14a\noW__\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`@\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x92\x91PPV\xFE\xA2dipfsX\"\x12 Y\xA4\x04\xB0~\xA6\x144*\xC4\x0E%\xDF:\x8E\x04$\xC2\xD4R_\xBE{\x9D\xF8\xB9B\xB6\x18j1\x08dsolcC\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\0\x85W_5`\xE0\x1C\x80c\\Yh\xBB\x11a\0XW\x80c\\Yh\xBB\x14a\0\xFEW\x80c\xCE\x1B\x81_\x14a\x01zW\x80c\xDB\xE5\xBA\xB5\x14a\x01\x94W\x80c\xF8\x18\x11p\x14a\x01\xAAW__\xFD[\x80c\x04\xBC\x1E{\x14a\0\x89W\x80c\"\xECT\xA0\x14a\0\x9EW\x80c*X\xB30\x14a\0\xB1W\x80cW+l\x05\x14a\0\xCDW[__\xFD[a\0\x9Ca\0\x976`\x04a\x0CAV[a\x01\xBDV[\0[a\0\x9Ca\0\xAC6`\x04a\x0CsV[a\x02\xE7V[a\0\xBA`\x02T\x81V[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\xEEa\0\xDB6`\x04a\x0C\xB4V[_T`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x91\x16\x14\x90V[`@Q\x90\x15\x15\x81R` \x01a\0\xC4V[a\x01Ha\x01\x0C6`\x04a\x0CAV[`\x01` \x81\x90R_\x91\x82R`@\x90\x91 \x80T\x91\x81\x01T`\x02\x82\x01T`\x03\x83\x01T`\x04\x90\x93\x01T`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x93\x91\x92\x91\x82\x16\x91\x16\x85V[`@\x80Q\x95\x86R`\x01`\x01`\xA0\x1B\x03\x94\x85\x16` \x87\x01R\x85\x01\x92\x90\x92R\x82\x16``\x84\x01R\x16`\x80\x82\x01R`\xA0\x01a\0\xC4V[_T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\0\xC4V[a\x01\x9Ca\x04rV[`@Qa\0\xC4\x92\x91\x90a\r\x07V[a\0\x9Ca\x01\xB86`\x04a\r\xA9V[a\x06>V[_\x81\x81R`\x01` \x81\x81R`@\x92\x83\x90 \x83Q`\xA0\x81\x01\x85R\x81T\x81R\x92\x81\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x92\x84\x01\x92\x90\x92R`\x02\x81\x01T\x93\x83\x01\x93\x90\x93R`\x03\x83\x01T\x81\x16``\x83\x01R`\x04\x90\x92\x01T\x90\x91\x16`\x80\x82\x01Ra\x02\x1Ea\x07\xE8V[`\x01`\x01`\xA0\x1B\x03\x16\x81`\x80\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x14a\x02>W__\xFD[a\x02`a\x02Ia\x07\xE8V[\x82Q` \x84\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x91\x90a\x088V[_\x82\x81R`\x01` \x81\x90R`@\x80\x83 \x83\x81U\x91\x82\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\x90\x81\x16\x90\x91U`\x02\x83\x01\x84\x90U`\x03\x83\x01\x80T\x82\x16\x90U`\x04\x90\x92\x01\x80T\x90\x92\x16\x90\x91UQ\x83\x91\x7F\xFBy\x1B\x0B\x90\xB7Jb\xA7\xD09X3b\xB4\xBE$K\x07\"rb##\x94\xE9#\xC1d\x88\xED1\x91\xA2PPV[`\x01`\x01`\xA0\x1B\x03\x84\x16a\x02\xF9W__\xFD[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x03\x0BW__\xFD[a\x03(a\x03\x16a\x07\xE8V[`\x01`\x01`\xA0\x1B\x03\x86\x16\x900\x86a\t\x04V[`\x02\x80T_\x91\x82a\x038\x83a\r\xF6V[\x91\x90PU\x90P_`@Q\x80`\xA0\x01`@R\x80\x86\x81R` \x01\x87`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x84\x81R` \x01\x85`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a\x03|a\x07\xE8V[`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x90\x91R_\x84\x81R`\x01` \x81\x81R`@\x92\x83\x90 \x85Q\x80\x82U\x91\x86\x01Q\x92\x81\x01\x80T\x84\x87\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\x84\x87\x01Q`\x02\x83\x01\x81\x90U``\x88\x01Q`\x03\x84\x01\x80T\x82\x8A\x16\x90\x85\x16\x17\x90U`\x80\x89\x01Q`\x04\x90\x94\x01\x80T\x94\x90\x98\x16\x93\x90\x92\x16\x83\x17\x90\x96U\x93Q\x95\x96P\x94\x87\x94\x7F\xC4\x04j0\\Y\xED\xB2G.c\x8A(\xCE\xDB\x16V<\x8A\xA0\xA4\xF8\xFA\xFF\xCA\xEF\x1CC\xA2o\x88l\x94a\x04b\x94\x92\x93\x84R`\x01`\x01`\xA0\x1B\x03\x92\x83\x16` \x85\x01R`@\x84\x01\x91\x90\x91R\x16``\x82\x01R`\x80\x01\x90V[`@Q\x80\x91\x03\x90\xA3PPPPPPV[``\x80_\x80[`\x02T\x81\x10\x15a\x04\xABW_\x81\x81R`\x01` R`@\x90 T\x15a\x04\xA3W\x81a\x04\x9F\x81a\r\xF6V[\x92PP[`\x01\x01a\x04xV[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x04\xC6Wa\x04\xC6a\x0E\x0EV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x05\x1DW\x81` \x01[`@\x80Q`\xA0\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x92\x82\x01\x81\x90R``\x82\x01\x81\x90R`\x80\x82\x01R\x82R_\x19\x90\x92\x01\x91\x01\x81a\x04\xE4W\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x05:Wa\x05:a\x0E\x0EV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x05cW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x02T\x81\x10\x15a\x062W_\x81\x81R`\x01` R`@\x90 T\x15a\x06*W_\x81\x81R`\x01` \x81\x81R`@\x92\x83\x90 \x83Q`\xA0\x81\x01\x85R\x81T\x81R\x92\x81\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x92\x84\x01\x92\x90\x92R`\x02\x81\x01T\x93\x83\x01\x93\x90\x93R`\x03\x83\x01T\x81\x16``\x83\x01R`\x04\x90\x92\x01T\x90\x91\x16`\x80\x82\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x05\xF3Wa\x05\xF3a\x0E;V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x06\x11Wa\x06\x11a\x0E;V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x06&\x81a\r\xF6V[\x92PP[`\x01\x01a\x05iV[P\x91\x95\x90\x94P\x92PPPV[_\x82\x81R`\x01` \x81\x81R`@\x92\x83\x90 \x83Q`\xA0\x81\x01\x85R\x81T\x81R\x92\x81\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x92\x84\x01\x92\x90\x92R`\x02\x81\x01T\x93\x83\x01\x93\x90\x93R`\x03\x83\x01T\x81\x16``\x83\x01R`\x04\x90\x92\x01T\x90\x91\x16`\x80\x82\x01\x81\x90Ra\x06\xA1W__\xFD[\x80`@\x01Q\x82\x11\x15a\x06\xB1W__\xFD[`@\x81\x01Q\x81Q_\x91\x90a\x06\xC5\x90\x85a\x0EhV[a\x06\xCF\x91\x90a\x0E\x85V[\x90P_\x83\x11a\x06\xE0Wa\x06\xE0a\x0E\xBDV[_\x81\x11a\x06\xEFWa\x06\xEFa\x0E\xBDV[\x81Q\x81\x11\x15a\x07\0Wa\x07\0a\x0E\xBDV[_\x84\x81R`\x01` R`@\x81 \x80T\x83\x92\x90a\x07\x1D\x90\x84\x90a\x0E\xEAV[\x90\x91UPP_\x84\x81R`\x01` R`@\x81 `\x02\x01\x80T\x85\x92\x90a\x07B\x90\x84\x90a\x0E\xEAV[\x90\x91UPa\x07n\x90Pa\x07Sa\x07\xE8V[`\x80\x84\x01Q``\x85\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x91\x90\x86a\t\x04V[a\x07\x8Ea\x07ya\x07\xE8V[` \x84\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x90\x83a\x088V[a\x07\x96a\x07\xE8V[`\x01`\x01`\xA0\x1B\x03\x16\x84\x7F\x01\x1F\xCFo\xC5?\xC7\x99q\xC9\xE9?\x9A\xDC\xEDl\x1F'#\x17{K\x92\xBE\x86\x10+\x05X\xFB\xB08\x83\x86`@Qa\x07\xDA\x92\x91\x90\x91\x82R` \x82\x01R`@\x01\x90V[`@Q\x80\x91\x03\x90\xA3PPPPV[_`\x146\x10\x80\x15\x90a\x08\x03WP_T`\x01`\x01`\xA0\x1B\x03\x163\x14[\x15a\x083WP\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xEC6\x015``\x1C\x90V[P3\x90V[`@Q`\x01`\x01`\xA0\x1B\x03\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x08\xFF\x90\x84\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\x90`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\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\t[V[PPPV[`@Q`\x01`\x01`\xA0\x1B\x03\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\tU\x90\x85\x90\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\x90`\x84\x01a\x08}V[PPPPV[_a\t\xAF\x82`@Q\x80`@\x01`@R\x80` \x81R` \x01\x7FSafeERC20: low-level call failed\x81RP\x85`\x01`\x01`\xA0\x1B\x03\x16a\n^\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x08\xFFW\x80\x80` \x01\x90Q\x81\x01\x90a\t\xCD\x91\x90a\x0E\xFDV[a\x08\xFFW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x01[`@Q\x80\x91\x03\x90\xFD[``a\nl\x84\x84_\x85a\nvV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x0B\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`&`$\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\nUV[`\x01`\x01`\xA0\x1B\x03\x85\x16;a\x0ByW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\nUV[__\x86`\x01`\x01`\xA0\x1B\x03\x16\x85\x87`@Qa\x0B\x94\x91\x90a\x0F\x1CV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x0B\xCEW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x0B\xD3V[``\x91P[P\x91P\x91Pa\x0B\xE3\x82\x82\x86a\x0B\xEEV[\x97\x96PPPPPPPV[``\x83\x15a\x0B\xFDWP\x81a\noV[\x82Q\x15a\x0C\rW\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\nU\x91\x90a\x0F2V[_` \x82\x84\x03\x12\x15a\x0CQW__\xFD[P5\x91\x90PV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0CnW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0C\x86W__\xFD[a\x0C\x8F\x85a\x0CXV[\x93P` \x85\x015\x92Pa\x0C\xA4`@\x86\x01a\x0CXV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[_` \x82\x84\x03\x12\x15a\x0C\xC4W__\xFD[a\no\x82a\x0CXV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x0C\xFDW\x81Q\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x0C\xDFV[P\x93\x94\x93PPPPV[`@\x80\x82R\x83Q\x90\x82\x01\x81\x90R_\x90` \x85\x01\x90``\x84\x01\x90\x83[\x81\x81\x10\x15a\r\x8BW\x83Q\x80Q\x84R`\x01`\x01`\xA0\x1B\x03` \x82\x01Q\x16` \x85\x01R`@\x81\x01Q`@\x85\x01R`\x01`\x01`\xA0\x1B\x03``\x82\x01Q\x16``\x85\x01R`\x01`\x01`\xA0\x1B\x03`\x80\x82\x01Q\x16`\x80\x85\x01RP`\xA0\x83\x01\x92P` \x84\x01\x93P`\x01\x81\x01\x90Pa\r\"V[PP\x83\x81\x03` \x85\x01Ra\r\x9F\x81\x86a\x0C\xCDV[\x96\x95PPPPPPV[__`@\x83\x85\x03\x12\x15a\r\xBAW__\xFD[PP\x805\x92` \x90\x91\x015\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`\x11`\x04R`$_\xFD[__\x19\x82\x03a\x0E\x07Wa\x0E\x07a\r\xC9V[P`\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`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[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x0E\x7FWa\x0E\x7Fa\r\xC9V[\x92\x91PPV[_\x82a\x0E\xB8W\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[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`\x01`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x0E\x7FWa\x0E\x7Fa\r\xC9V[_` \x82\x84\x03\x12\x15a\x0F\rW__\xFD[\x81Q\x80\x15\x15\x81\x14a\noW__\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`@\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x92\x91PPV\xFE\xA2dipfsX\"\x12 Y\xA4\x04\xB0~\xA6\x144*\xC4\x0E%\xDF:\x8E\x04$\xC2\xD4R_\xBE{\x9D\xF8\xB9B\xB6\x18j1\x08dsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct Order { uint256 offeringAmount; address offeringToken; uint256 askingAmount; address askingToken; address requesterAddress; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Order { + #[allow(missing_docs)] + pub offeringAmount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub offeringToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub askingAmount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub askingToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub requesterAddress: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + 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::Address, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: Order) -> Self { + ( + value.offeringAmount, + value.offeringToken, + value.askingAmount, + value.askingToken, + value.requesterAddress, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for Order { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + offeringAmount: tuple.0, + offeringToken: tuple.1, + askingAmount: tuple.2, + askingToken: tuple.3, + requesterAddress: tuple.4, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for Order { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for Order { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.offeringAmount), + ::tokenize( + &self.offeringToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.askingAmount), + ::tokenize( + &self.askingToken, + ), + ::tokenize( + &self.requesterAddress, + ), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + 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> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::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(uint256 offeringAmount,address offeringToken,uint256 askingAmount,address askingToken,address requesterAddress)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + as alloy_sol_types::SolType>::eip712_data_word( + &self.offeringAmount, + ) + .0, + ::eip712_data_word( + &self.offeringToken, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.askingAmount) + .0, + ::eip712_data_word( + &self.askingToken, + ) + .0, + ::eip712_data_word( + &self.requesterAddress, + ) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Order { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.offeringAmount, + ) + + ::topic_preimage_length( + &rust.offeringToken, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.askingAmount, + ) + + ::topic_preimage_length( + &rust.askingToken, + ) + + ::topic_preimage_length( + &rust.requesterAddress, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.offeringAmount, + out, + ); + ::encode_topic_preimage( + &rust.offeringToken, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.askingAmount, + out, + ); + ::encode_topic_preimage( + &rust.askingToken, + out, + ); + ::encode_topic_preimage( + &rust.requesterAddress, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `acceptOrder(uint256,address,uint256,uint256)` and selector `0x011fcf6fc53fc79971c9e93f9adced6c1f2723177b4b92be86102b0558fbb038`. +```solidity +event acceptOrder(uint256 indexed orderId, address indexed who, uint256 buyAmount, uint256 saleAmount); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct acceptOrder { + #[allow(missing_docs)] + pub orderId: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub who: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub buyAmount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub saleAmount: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for acceptOrder { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + ); + const SIGNATURE: &'static str = "acceptOrder(uint256,address,uint256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 1u8, 31u8, 207u8, 111u8, 197u8, 63u8, 199u8, 153u8, 113u8, 201u8, 233u8, + 63u8, 154u8, 220u8, 237u8, 108u8, 31u8, 39u8, 35u8, 23u8, 123u8, 75u8, + 146u8, 190u8, 134u8, 16u8, 43u8, 5u8, 88u8, 251u8, 176u8, 56u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + orderId: topics.1, + who: topics.2, + buyAmount: data.0, + saleAmount: data.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.buyAmount), + as alloy_sol_types::SolType>::tokenize(&self.saleAmount), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.orderId.clone(), self.who.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.orderId); + out[2usize] = ::encode_topic( + &self.who, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for acceptOrder { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&acceptOrder> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &acceptOrder) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `placeOrder(uint256,address,uint256,address,uint256,address)` and selector `0xc4046a305c59edb2472e638a28cedb16563c8aa0a4f8faffcaef1c43a26f886c`. +```solidity +event placeOrder(uint256 indexed orderId, address indexed requesterAddress, uint256 offeringAmount, address offeringToken, uint256 askingAmount, address askingToken); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct placeOrder { + #[allow(missing_docs)] + pub orderId: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub requesterAddress: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub offeringAmount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub offeringToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub askingAmount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub askingToken: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for placeOrder { + type DataTuple<'a> = ( + 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 DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + ); + const SIGNATURE: &'static str = "placeOrder(uint256,address,uint256,address,uint256,address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 196u8, 4u8, 106u8, 48u8, 92u8, 89u8, 237u8, 178u8, 71u8, 46u8, 99u8, + 138u8, 40u8, 206u8, 219u8, 22u8, 86u8, 60u8, 138u8, 160u8, 164u8, 248u8, + 250u8, 255u8, 202u8, 239u8, 28u8, 67u8, 162u8, 111u8, 136u8, 108u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + orderId: topics.1, + requesterAddress: topics.2, + offeringAmount: data.0, + offeringToken: data.1, + askingAmount: data.2, + askingToken: data.3, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.offeringAmount), + ::tokenize( + &self.offeringToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.askingAmount), + ::tokenize( + &self.askingToken, + ), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + ( + Self::SIGNATURE_HASH.into(), + self.orderId.clone(), + self.requesterAddress.clone(), + ) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.orderId); + out[2usize] = ::encode_topic( + &self.requesterAddress, + ); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for placeOrder { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&placeOrder> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &placeOrder) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `withdrawOrder(uint256)` and selector `0xfb791b0b90b74a62a7d039583362b4be244b07227262232394e923c16488ed31`. +```solidity +event withdrawOrder(uint256 indexed orderId); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct withdrawOrder { + #[allow(missing_docs)] + pub orderId: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for withdrawOrder { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + ); + const SIGNATURE: &'static str = "withdrawOrder(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 251u8, 121u8, 27u8, 11u8, 144u8, 183u8, 74u8, 98u8, 167u8, 208u8, 57u8, + 88u8, 51u8, 98u8, 180u8, 190u8, 36u8, 75u8, 7u8, 34u8, 114u8, 98u8, 35u8, + 35u8, 148u8, 233u8, 35u8, 193u8, 100u8, 136u8, 237u8, 49u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { orderId: topics.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return 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) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.orderId.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.orderId); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for withdrawOrder { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&withdrawOrder> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &withdrawOrder) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(address erc2771Forwarder); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub erc2771Forwarder: alloy::sol_types::private::Address, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value.erc2771Forwarder,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { erc2771Forwarder: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolConstructor for constructorCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.erc2771Forwarder, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `acceptErcErcOrder(uint256,uint256)` and selector `0xf8181170`. +```solidity +function acceptErcErcOrder(uint256 id, uint256 saleAmount) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct acceptErcErcOrderCall { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub saleAmount: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`acceptErcErcOrder(uint256,uint256)`](acceptErcErcOrderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct acceptErcErcOrderReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: acceptErcErcOrderCall) -> Self { + (value.id, value.saleAmount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for acceptErcErcOrderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + id: tuple.0, + saleAmount: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: acceptErcErcOrderReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for acceptErcErcOrderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl acceptErcErcOrderReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for acceptErcErcOrderCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = acceptErcErcOrderReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "acceptErcErcOrder(uint256,uint256)"; + const SELECTOR: [u8; 4] = [248u8, 24u8, 17u8, 112u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + as alloy_sol_types::SolType>::tokenize(&self.saleAmount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + acceptErcErcOrderReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `ercErcOrders(uint256)` and selector `0x5c5968bb`. +```solidity +function ercErcOrders(uint256) external view returns (uint256 offeringAmount, address offeringToken, uint256 askingAmount, address askingToken, address requesterAddress); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ercErcOrdersCall( + pub alloy::sol_types::private::primitives::aliases::U256, + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`ercErcOrders(uint256)`](ercErcOrdersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ercErcOrdersReturn { + #[allow(missing_docs)] + pub offeringAmount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub offeringToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub askingAmount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub askingToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub requesterAddress: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ercErcOrdersCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ercErcOrdersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + 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::Address, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ercErcOrdersReturn) -> Self { + ( + value.offeringAmount, + value.offeringToken, + value.askingAmount, + value.askingToken, + value.requesterAddress, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ercErcOrdersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + offeringAmount: tuple.0, + offeringToken: tuple.1, + askingAmount: tuple.2, + askingToken: tuple.3, + requesterAddress: tuple.4, + } + } + } + } + impl ercErcOrdersReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.offeringAmount), + ::tokenize( + &self.offeringToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.askingAmount), + ::tokenize( + &self.askingToken, + ), + ::tokenize( + &self.requesterAddress, + ), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for ercErcOrdersCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ercErcOrdersReturn; + type ReturnTuple<'a> = ( + 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::Address, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ercErcOrders(uint256)"; + const SELECTOR: [u8; 4] = [92u8, 89u8, 104u8, 187u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.0), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ercErcOrdersReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `getOpenOrders()` and selector `0xdbe5bab5`. +```solidity +function getOpenOrders() external view returns (Order[] memory, uint256[] memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getOpenOrdersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`getOpenOrders()`](getOpenOrdersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getOpenOrdersReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Vec< + ::RustType, + >, + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: getOpenOrdersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for getOpenOrdersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: getOpenOrdersReturn) -> Self { + (value._0, value._1) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for getOpenOrdersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0, _1: tuple.1 } + } + } + } + impl getOpenOrdersReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + , + > as alloy_sol_types::SolType>::tokenize(&self._1), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getOpenOrdersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = getOpenOrdersReturn; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array>, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getOpenOrders()"; + const SELECTOR: [u8; 4] = [219u8, 229u8, 186u8, 181u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + getOpenOrdersReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `getTrustedForwarder()` and selector `0xce1b815f`. +```solidity +function getTrustedForwarder() external view returns (address forwarder); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getTrustedForwarderCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`getTrustedForwarder()`](getTrustedForwarderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getTrustedForwarderReturn { + #[allow(missing_docs)] + pub forwarder: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getTrustedForwarderCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getTrustedForwarderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getTrustedForwarderReturn) -> Self { + (value.forwarder,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getTrustedForwarderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { forwarder: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getTrustedForwarderCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getTrustedForwarder()"; + const SELECTOR: [u8; 4] = [206u8, 27u8, 129u8, 95u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: getTrustedForwarderReturn = r.into(); + r.forwarder + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: getTrustedForwarderReturn = r.into(); + r.forwarder + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `isTrustedForwarder(address)` and selector `0x572b6c05`. +```solidity +function isTrustedForwarder(address forwarder) external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isTrustedForwarderCall { + #[allow(missing_docs)] + pub forwarder: alloy::sol_types::private::Address, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`isTrustedForwarder(address)`](isTrustedForwarderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct isTrustedForwarderReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isTrustedForwarderCall) -> Self { + (value.forwarder,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isTrustedForwarderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { forwarder: tuple.0 } + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: isTrustedForwarderReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for isTrustedForwarderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for isTrustedForwarderCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "isTrustedForwarder(address)"; + const SELECTOR: [u8; 4] = [87u8, 43u8, 108u8, 5u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.forwarder, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: isTrustedForwarderReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: isTrustedForwarderReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `nextOrderId()` and selector `0x2a58b330`. +```solidity +function nextOrderId() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct nextOrderIdCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`nextOrderId()`](nextOrderIdCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct nextOrderIdReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: nextOrderIdCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for nextOrderIdCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: nextOrderIdReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for nextOrderIdReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for nextOrderIdCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "nextOrderId()"; + const SELECTOR: [u8; 4] = [42u8, 88u8, 179u8, 48u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: nextOrderIdReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: nextOrderIdReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `placeErcErcOrder(address,uint256,address,uint256)` and selector `0x22ec54a0`. +```solidity +function placeErcErcOrder(address sellingToken, uint256 saleAmount, address buyingToken, uint256 buyAmount) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct placeErcErcOrderCall { + #[allow(missing_docs)] + pub sellingToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub saleAmount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub buyingToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub buyAmount: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`placeErcErcOrder(address,uint256,address,uint256)`](placeErcErcOrderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct placeErcErcOrderReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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>, + ); + #[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, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: placeErcErcOrderCall) -> Self { + ( + value.sellingToken, + value.saleAmount, + value.buyingToken, + value.buyAmount, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for placeErcErcOrderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + sellingToken: tuple.0, + saleAmount: tuple.1, + buyingToken: tuple.2, + buyAmount: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: placeErcErcOrderReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for placeErcErcOrderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl placeErcErcOrderReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for placeErcErcOrderCall { + 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>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = placeErcErcOrderReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "placeErcErcOrder(address,uint256,address,uint256)"; + const SELECTOR: [u8; 4] = [34u8, 236u8, 84u8, 160u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.sellingToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.saleAmount), + ::tokenize( + &self.buyingToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.buyAmount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + placeErcErcOrderReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `withdrawErcErcOrder(uint256)` and selector `0x04bc1e7b`. +```solidity +function withdrawErcErcOrder(uint256 id) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct withdrawErcErcOrderCall { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`withdrawErcErcOrder(uint256)`](withdrawErcErcOrderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct withdrawErcErcOrderReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: withdrawErcErcOrderCall) -> Self { + (value.id,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for withdrawErcErcOrderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { id: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: withdrawErcErcOrderReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for withdrawErcErcOrderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl withdrawErcErcOrderReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for withdrawErcErcOrderCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = withdrawErcErcOrderReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "withdrawErcErcOrder(uint256)"; + const SELECTOR: [u8; 4] = [4u8, 188u8, 30u8, 123u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + withdrawErcErcOrderReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + ///Container for all the [`MarketPlace`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum MarketPlaceCalls { + #[allow(missing_docs)] + acceptErcErcOrder(acceptErcErcOrderCall), + #[allow(missing_docs)] + ercErcOrders(ercErcOrdersCall), + #[allow(missing_docs)] + getOpenOrders(getOpenOrdersCall), + #[allow(missing_docs)] + getTrustedForwarder(getTrustedForwarderCall), + #[allow(missing_docs)] + isTrustedForwarder(isTrustedForwarderCall), + #[allow(missing_docs)] + nextOrderId(nextOrderIdCall), + #[allow(missing_docs)] + placeErcErcOrder(placeErcErcOrderCall), + #[allow(missing_docs)] + withdrawErcErcOrder(withdrawErcErcOrderCall), + } + #[automatically_derived] + impl MarketPlaceCalls { + /// 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]] = &[ + [4u8, 188u8, 30u8, 123u8], + [34u8, 236u8, 84u8, 160u8], + [42u8, 88u8, 179u8, 48u8], + [87u8, 43u8, 108u8, 5u8], + [92u8, 89u8, 104u8, 187u8], + [206u8, 27u8, 129u8, 95u8], + [219u8, 229u8, 186u8, 181u8], + [248u8, 24u8, 17u8, 112u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for MarketPlaceCalls { + const NAME: &'static str = "MarketPlaceCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 8usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::acceptErcErcOrder(_) => { + ::SELECTOR + } + Self::ercErcOrders(_) => { + ::SELECTOR + } + Self::getOpenOrders(_) => { + ::SELECTOR + } + Self::getTrustedForwarder(_) => { + ::SELECTOR + } + Self::isTrustedForwarder(_) => { + ::SELECTOR + } + Self::nextOrderId(_) => { + ::SELECTOR + } + Self::placeErcErcOrder(_) => { + ::SELECTOR + } + Self::withdrawErcErcOrder(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn withdrawErcErcOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(MarketPlaceCalls::withdrawErcErcOrder) + } + withdrawErcErcOrder + }, + { + fn placeErcErcOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(MarketPlaceCalls::placeErcErcOrder) + } + placeErcErcOrder + }, + { + fn nextOrderId( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(MarketPlaceCalls::nextOrderId) + } + nextOrderId + }, + { + fn isTrustedForwarder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(MarketPlaceCalls::isTrustedForwarder) + } + isTrustedForwarder + }, + { + fn ercErcOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(MarketPlaceCalls::ercErcOrders) + } + ercErcOrders + }, + { + fn getTrustedForwarder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(MarketPlaceCalls::getTrustedForwarder) + } + getTrustedForwarder + }, + { + fn getOpenOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(MarketPlaceCalls::getOpenOrders) + } + getOpenOrders + }, + { + fn acceptErcErcOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(MarketPlaceCalls::acceptErcErcOrder) + } + acceptErcErcOrder + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn withdrawErcErcOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MarketPlaceCalls::withdrawErcErcOrder) + } + withdrawErcErcOrder + }, + { + fn placeErcErcOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MarketPlaceCalls::placeErcErcOrder) + } + placeErcErcOrder + }, + { + fn nextOrderId( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MarketPlaceCalls::nextOrderId) + } + nextOrderId + }, + { + fn isTrustedForwarder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MarketPlaceCalls::isTrustedForwarder) + } + isTrustedForwarder + }, + { + fn ercErcOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MarketPlaceCalls::ercErcOrders) + } + ercErcOrders + }, + { + fn getTrustedForwarder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MarketPlaceCalls::getTrustedForwarder) + } + getTrustedForwarder + }, + { + fn getOpenOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MarketPlaceCalls::getOpenOrders) + } + getOpenOrders + }, + { + fn acceptErcErcOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(MarketPlaceCalls::acceptErcErcOrder) + } + acceptErcErcOrder + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::acceptErcErcOrder(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ercErcOrders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getOpenOrders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getTrustedForwarder(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::isTrustedForwarder(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::nextOrderId(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::placeErcErcOrder(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::withdrawErcErcOrder(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::acceptErcErcOrder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ercErcOrders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getOpenOrders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getTrustedForwarder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::isTrustedForwarder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::nextOrderId(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::placeErcErcOrder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::withdrawErcErcOrder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`MarketPlace`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum MarketPlaceEvents { + #[allow(missing_docs)] + acceptOrder(acceptOrder), + #[allow(missing_docs)] + placeOrder(placeOrder), + #[allow(missing_docs)] + withdrawOrder(withdrawOrder), + } + #[automatically_derived] + impl MarketPlaceEvents { + /// 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, 31u8, 207u8, 111u8, 197u8, 63u8, 199u8, 153u8, 113u8, 201u8, 233u8, + 63u8, 154u8, 220u8, 237u8, 108u8, 31u8, 39u8, 35u8, 23u8, 123u8, 75u8, + 146u8, 190u8, 134u8, 16u8, 43u8, 5u8, 88u8, 251u8, 176u8, 56u8, + ], + [ + 196u8, 4u8, 106u8, 48u8, 92u8, 89u8, 237u8, 178u8, 71u8, 46u8, 99u8, + 138u8, 40u8, 206u8, 219u8, 22u8, 86u8, 60u8, 138u8, 160u8, 164u8, 248u8, + 250u8, 255u8, 202u8, 239u8, 28u8, 67u8, 162u8, 111u8, 136u8, 108u8, + ], + [ + 251u8, 121u8, 27u8, 11u8, 144u8, 183u8, 74u8, 98u8, 167u8, 208u8, 57u8, + 88u8, 51u8, 98u8, 180u8, 190u8, 36u8, 75u8, 7u8, 34u8, 114u8, 98u8, 35u8, + 35u8, 148u8, 233u8, 35u8, 193u8, 100u8, 136u8, 237u8, 49u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for MarketPlaceEvents { + const NAME: &'static str = "MarketPlaceEvents"; + const COUNT: usize = 3usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::acceptOrder) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::placeOrder) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::withdrawOrder) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 MarketPlaceEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::acceptOrder(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::placeOrder(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::withdrawOrder(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::acceptOrder(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::placeOrder(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::withdrawOrder(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`MarketPlace`](self) contract instance. + +See the [wrapper's documentation](`MarketPlaceInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> MarketPlaceInstance { + MarketPlaceInstance::::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: alloy_contract::private::Network, + >( + provider: P, + erc2771Forwarder: alloy::sol_types::private::Address, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + MarketPlaceInstance::::deploy(provider, erc2771Forwarder) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + erc2771Forwarder: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + MarketPlaceInstance::::deploy_builder(provider, erc2771Forwarder) + } + /**A [`MarketPlace`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`MarketPlace`](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 MarketPlaceInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for MarketPlaceInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("MarketPlaceInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > MarketPlaceInstance { + /**Creates a new wrapper around an on-chain [`MarketPlace`](self) contract instance. + +See the [wrapper's documentation](`MarketPlaceInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + erc2771Forwarder: alloy::sol_types::private::Address, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(provider, erc2771Forwarder); + 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, + erc2771Forwarder: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + erc2771Forwarder, + }, + )[..], + ] + .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 MarketPlaceInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> MarketPlaceInstance { + MarketPlaceInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > MarketPlaceInstance { + /// 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( + &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 [`acceptErcErcOrder`] function. + pub fn acceptErcErcOrder( + &self, + id: alloy::sol_types::private::primitives::aliases::U256, + saleAmount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, acceptErcErcOrderCall, N> { + self.call_builder( + &acceptErcErcOrderCall { + id, + saleAmount, + }, + ) + } + ///Creates a new call builder for the [`ercErcOrders`] function. + pub fn ercErcOrders( + &self, + _0: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, ercErcOrdersCall, N> { + self.call_builder(&ercErcOrdersCall(_0)) + } + ///Creates a new call builder for the [`getOpenOrders`] function. + pub fn getOpenOrders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, getOpenOrdersCall, N> { + self.call_builder(&getOpenOrdersCall) + } + ///Creates a new call builder for the [`getTrustedForwarder`] function. + pub fn getTrustedForwarder( + &self, + ) -> alloy_contract::SolCallBuilder<&P, getTrustedForwarderCall, N> { + self.call_builder(&getTrustedForwarderCall) + } + ///Creates a new call builder for the [`isTrustedForwarder`] function. + pub fn isTrustedForwarder( + &self, + forwarder: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, isTrustedForwarderCall, N> { + self.call_builder( + &isTrustedForwarderCall { + forwarder, + }, + ) + } + ///Creates a new call builder for the [`nextOrderId`] function. + pub fn nextOrderId( + &self, + ) -> alloy_contract::SolCallBuilder<&P, nextOrderIdCall, N> { + self.call_builder(&nextOrderIdCall) + } + ///Creates a new call builder for the [`placeErcErcOrder`] function. + pub fn placeErcErcOrder( + &self, + sellingToken: alloy::sol_types::private::Address, + saleAmount: alloy::sol_types::private::primitives::aliases::U256, + buyingToken: alloy::sol_types::private::Address, + buyAmount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, placeErcErcOrderCall, N> { + self.call_builder( + &placeErcErcOrderCall { + sellingToken, + saleAmount, + buyingToken, + buyAmount, + }, + ) + } + ///Creates a new call builder for the [`withdrawErcErcOrder`] function. + pub fn withdrawErcErcOrder( + &self, + id: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, withdrawErcErcOrderCall, N> { + self.call_builder(&withdrawErcErcOrderCall { id }) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > MarketPlaceInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`acceptOrder`] event. + pub fn acceptOrder_filter(&self) -> alloy_contract::Event<&P, acceptOrder, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`placeOrder`] event. + pub fn placeOrder_filter(&self) -> alloy_contract::Event<&P, placeOrder, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`withdrawOrder`] event. + pub fn withdrawOrder_filter( + &self, + ) -> alloy_contract::Event<&P, withdrawOrder, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/ord_marketplace.rs b/crates/bindings/src/ord_marketplace.rs new file mode 100644 index 000000000..a21782d35 --- /dev/null +++ b/crates/bindings/src/ord_marketplace.rs @@ -0,0 +1,6113 @@ +///Module containing a contract's types and functions. +/** + +```solidity +library BitcoinTx { + struct Info { bytes4 version; bytes inputVector; bytes outputVector; bytes4 locktime; } + struct Proof { bytes merkleProof; uint256 txIndexInBlock; bytes bitcoinHeaders; bytes32 coinbasePreimage; bytes coinbaseProof; } + struct UTXO { bytes32 txHash; uint32 txOutputIndex; uint64 txOutputValue; } +} +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod BitcoinTx { + use super::*; + use alloy::sol_types as alloy_sol_types; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct Info { bytes4 version; bytes inputVector; bytes outputVector; bytes4 locktime; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Info { + #[allow(missing_docs)] + pub version: alloy::sol_types::private::FixedBytes<4>, + #[allow(missing_docs)] + pub inputVector: alloy::sol_types::private::Bytes, + #[allow(missing_docs)] + pub outputVector: alloy::sol_types::private::Bytes, + #[allow(missing_docs)] + pub locktime: 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 as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::FixedBytes<4>, + alloy::sol_types::sol_data::Bytes, + alloy::sol_types::sol_data::Bytes, + alloy::sol_types::sol_data::FixedBytes<4>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::FixedBytes<4>, + alloy::sol_types::private::Bytes, + alloy::sol_types::private::Bytes, + alloy::sol_types::private::FixedBytes<4>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: Info) -> Self { + (value.version, value.inputVector, value.outputVector, value.locktime) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for Info { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + version: tuple.0, + inputVector: tuple.1, + outputVector: tuple.2, + locktime: tuple.3, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for Info { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for Info { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.version), + ::tokenize( + &self.inputVector, + ), + ::tokenize( + &self.outputVector, + ), + as alloy_sol_types::SolType>::tokenize(&self.locktime), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Info { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for Info { + const NAME: &'static str = "Info"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "Info(bytes4 version,bytes inputVector,bytes outputVector,bytes4 locktime)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + as alloy_sol_types::SolType>::eip712_data_word(&self.version) + .0, + ::eip712_data_word( + &self.inputVector, + ) + .0, + ::eip712_data_word( + &self.outputVector, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.locktime) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Info { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.version, + ) + + ::topic_preimage_length( + &rust.inputVector, + ) + + ::topic_preimage_length( + &rust.outputVector, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.locktime, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.version, + out, + ); + ::encode_topic_preimage( + &rust.inputVector, + out, + ); + ::encode_topic_preimage( + &rust.outputVector, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.locktime, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct Proof { bytes merkleProof; uint256 txIndexInBlock; bytes bitcoinHeaders; bytes32 coinbasePreimage; bytes coinbaseProof; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct Proof { + #[allow(missing_docs)] + pub merkleProof: alloy::sol_types::private::Bytes, + #[allow(missing_docs)] + pub txIndexInBlock: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub bitcoinHeaders: alloy::sol_types::private::Bytes, + #[allow(missing_docs)] + pub coinbasePreimage: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub coinbaseProof: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Bytes, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Bytes, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Bytes, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Bytes, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Bytes, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: Proof) -> Self { + ( + value.merkleProof, + value.txIndexInBlock, + value.bitcoinHeaders, + value.coinbasePreimage, + value.coinbaseProof, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for Proof { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + merkleProof: tuple.0, + txIndexInBlock: tuple.1, + bitcoinHeaders: tuple.2, + coinbasePreimage: tuple.3, + coinbaseProof: tuple.4, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for Proof { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for Proof { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.merkleProof, + ), + as alloy_sol_types::SolType>::tokenize(&self.txIndexInBlock), + ::tokenize( + &self.bitcoinHeaders, + ), + as alloy_sol_types::SolType>::tokenize(&self.coinbasePreimage), + ::tokenize( + &self.coinbaseProof, + ), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for Proof { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for Proof { + const NAME: &'static str = "Proof"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "Proof(bytes merkleProof,uint256 txIndexInBlock,bytes bitcoinHeaders,bytes32 coinbasePreimage,bytes coinbaseProof)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.merkleProof, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word( + &self.txIndexInBlock, + ) + .0, + ::eip712_data_word( + &self.bitcoinHeaders, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word( + &self.coinbasePreimage, + ) + .0, + ::eip712_data_word( + &self.coinbaseProof, + ) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for Proof { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.merkleProof, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.txIndexInBlock, + ) + + ::topic_preimage_length( + &rust.bitcoinHeaders, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.coinbasePreimage, + ) + + ::topic_preimage_length( + &rust.coinbaseProof, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.merkleProof, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.txIndexInBlock, + out, + ); + ::encode_topic_preimage( + &rust.bitcoinHeaders, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.coinbasePreimage, + out, + ); + ::encode_topic_preimage( + &rust.coinbaseProof, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct UTXO { bytes32 txHash; uint32 txOutputIndex; uint64 txOutputValue; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct UTXO { + #[allow(missing_docs)] + pub txHash: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub txOutputIndex: u32, + #[allow(missing_docs)] + pub txOutputValue: u64, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<32>, + alloy::sol_types::sol_data::Uint<64>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::FixedBytes<32>, + u32, + u64, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: UTXO) -> Self { + (value.txHash, value.txOutputIndex, value.txOutputValue) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for UTXO { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + txHash: tuple.0, + txOutputIndex: tuple.1, + txOutputValue: tuple.2, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for UTXO { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for UTXO { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.txHash), + as alloy_sol_types::SolType>::tokenize(&self.txOutputIndex), + as alloy_sol_types::SolType>::tokenize(&self.txOutputValue), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for UTXO { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for UTXO { + const NAME: &'static str = "UTXO"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "UTXO(bytes32 txHash,uint32 txOutputIndex,uint64 txOutputValue)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + as alloy_sol_types::SolType>::eip712_data_word(&self.txHash) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.txOutputIndex) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.txOutputValue) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for UTXO { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.txHash, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.txOutputIndex, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.txOutputValue, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.txHash, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.txOutputIndex, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.txOutputValue, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`BitcoinTx`](self) contract instance. + +See the [wrapper's documentation](`BitcoinTxInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> BitcoinTxInstance { + BitcoinTxInstance::::new(address, provider) + } + /**A [`BitcoinTx`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`BitcoinTx`](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 BitcoinTxInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for BitcoinTxInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("BitcoinTxInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BitcoinTxInstance { + /**Creates a new wrapper around an on-chain [`BitcoinTx`](self) contract instance. + +See the [wrapper's documentation](`BitcoinTxInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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 BitcoinTxInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> BitcoinTxInstance { + BitcoinTxInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BitcoinTxInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BitcoinTxInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} +/** + +Generated by the following Solidity interface... +```solidity +library BitcoinTx { + struct Info { + bytes4 version; + bytes inputVector; + bytes outputVector; + bytes4 locktime; + } + struct Proof { + bytes merkleProof; + uint256 txIndexInBlock; + bytes bitcoinHeaders; + bytes32 coinbasePreimage; + bytes coinbaseProof; + } + struct UTXO { + bytes32 txHash; + uint32 txOutputIndex; + uint64 txOutputValue; + } +} + +interface OrdMarketplace { + struct AcceptedOrdinalSellOrder { + uint256 orderId; + BitcoinAddress bitcoinAddress; + address ercToken; + uint256 ercAmount; + address requester; + address acceptor; + uint256 acceptTime; + } + struct BitcoinAddress { + bytes scriptPubKey; + } + struct OrdinalId { + bytes32 txId; + uint32 index; + } + struct OrdinalSellOrder { + OrdinalId ordinalID; + address sellToken; + uint256 sellAmount; + BitcoinTx.UTXO utxo; + address requester; + bool isOrderAccepted; + } + + event acceptOrdinalSellOrderEvent(uint256 indexed id, uint256 indexed acceptId, BitcoinAddress bitcoinAddress, address ercToken, uint256 ercAmount); + event cancelAcceptedOrdinalSellOrderEvent(uint256 id); + event placeOrdinalSellOrderEvent(uint256 indexed orderId, OrdinalId ordinalID, address sellToken, uint256 sellAmount); + event proofOrdinalSellOrderEvent(uint256 id); + event withdrawOrdinalSellOrderEvent(uint256 id); + + constructor(address _relay); + + function REQUEST_EXPIRATION_SECONDS() external view returns (uint256); + function acceptOrdinalSellOrder(uint256 id, BitcoinAddress memory bitcoinAddress) external returns (uint256); + function acceptedOrdinalSellOrders(uint256) external view returns (uint256 orderId, BitcoinAddress memory bitcoinAddress, address ercToken, uint256 ercAmount, address requester, address acceptor, uint256 acceptTime); + function cancelAcceptedOrdinalSellOrder(uint256 id) external; + function getOpenAcceptedOrdinalSellOrders() external view returns (AcceptedOrdinalSellOrder[] memory, uint256[] memory); + function getOpenOrdinalSellOrders() external view returns (OrdinalSellOrder[] memory, uint256[] memory); + function ordinalSellOrders(uint256) external view returns (OrdinalId memory ordinalID, address sellToken, uint256 sellAmount, BitcoinTx.UTXO memory utxo, address requester, bool isOrderAccepted); + function placeOrdinalSellOrder(OrdinalId memory ordinalID, BitcoinTx.UTXO memory utxo, address sellToken, uint256 sellAmount) external; + function proofOrdinalSellOrder(uint256 id, BitcoinTx.Info memory transaction, BitcoinTx.Proof memory proof) external; + function withdrawOrdinalSellOrder(uint256 id) external; +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_relay", + "type": "address", + "internalType": "contract TestLightRelay" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "REQUEST_EXPIRATION_SECONDS", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "acceptOrdinalSellOrder", + "inputs": [ + { + "name": "id", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "bitcoinAddress", + "type": "tuple", + "internalType": "struct OrdMarketplace.BitcoinAddress", + "components": [ + { + "name": "scriptPubKey", + "type": "bytes", + "internalType": "bytes" + } + ] + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "acceptedOrdinalSellOrders", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "orderId", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "bitcoinAddress", + "type": "tuple", + "internalType": "struct OrdMarketplace.BitcoinAddress", + "components": [ + { + "name": "scriptPubKey", + "type": "bytes", + "internalType": "bytes" + } + ] + }, + { + "name": "ercToken", + "type": "address", + "internalType": "address" + }, + { + "name": "ercAmount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "requester", + "type": "address", + "internalType": "address" + }, + { + "name": "acceptor", + "type": "address", + "internalType": "address" + }, + { + "name": "acceptTime", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "cancelAcceptedOrdinalSellOrder", + "inputs": [ + { + "name": "id", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "getOpenAcceptedOrdinalSellOrders", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "tuple[]", + "internalType": "struct OrdMarketplace.AcceptedOrdinalSellOrder[]", + "components": [ + { + "name": "orderId", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "bitcoinAddress", + "type": "tuple", + "internalType": "struct OrdMarketplace.BitcoinAddress", + "components": [ + { + "name": "scriptPubKey", + "type": "bytes", + "internalType": "bytes" + } + ] + }, + { + "name": "ercToken", + "type": "address", + "internalType": "address" + }, + { + "name": "ercAmount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "requester", + "type": "address", + "internalType": "address" + }, + { + "name": "acceptor", + "type": "address", + "internalType": "address" + }, + { + "name": "acceptTime", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "", + "type": "uint256[]", + "internalType": "uint256[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getOpenOrdinalSellOrders", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "tuple[]", + "internalType": "struct OrdMarketplace.OrdinalSellOrder[]", + "components": [ + { + "name": "ordinalID", + "type": "tuple", + "internalType": "struct OrdMarketplace.OrdinalId", + "components": [ + { + "name": "txId", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "index", + "type": "uint32", + "internalType": "uint32" + } + ] + }, + { + "name": "sellToken", + "type": "address", + "internalType": "address" + }, + { + "name": "sellAmount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "utxo", + "type": "tuple", + "internalType": "struct BitcoinTx.UTXO", + "components": [ + { + "name": "txHash", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "txOutputIndex", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "txOutputValue", + "type": "uint64", + "internalType": "uint64" + } + ] + }, + { + "name": "requester", + "type": "address", + "internalType": "address" + }, + { + "name": "isOrderAccepted", + "type": "bool", + "internalType": "bool" + } + ] + }, + { + "name": "", + "type": "uint256[]", + "internalType": "uint256[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "ordinalSellOrders", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "ordinalID", + "type": "tuple", + "internalType": "struct OrdMarketplace.OrdinalId", + "components": [ + { + "name": "txId", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "index", + "type": "uint32", + "internalType": "uint32" + } + ] + }, + { + "name": "sellToken", + "type": "address", + "internalType": "address" + }, + { + "name": "sellAmount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "utxo", + "type": "tuple", + "internalType": "struct BitcoinTx.UTXO", + "components": [ + { + "name": "txHash", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "txOutputIndex", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "txOutputValue", + "type": "uint64", + "internalType": "uint64" + } + ] + }, + { + "name": "requester", + "type": "address", + "internalType": "address" + }, + { + "name": "isOrderAccepted", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "placeOrdinalSellOrder", + "inputs": [ + { + "name": "ordinalID", + "type": "tuple", + "internalType": "struct OrdMarketplace.OrdinalId", + "components": [ + { + "name": "txId", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "index", + "type": "uint32", + "internalType": "uint32" + } + ] + }, + { + "name": "utxo", + "type": "tuple", + "internalType": "struct BitcoinTx.UTXO", + "components": [ + { + "name": "txHash", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "txOutputIndex", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "txOutputValue", + "type": "uint64", + "internalType": "uint64" + } + ] + }, + { + "name": "sellToken", + "type": "address", + "internalType": "address" + }, + { + "name": "sellAmount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "proofOrdinalSellOrder", + "inputs": [ + { + "name": "id", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "transaction", + "type": "tuple", + "internalType": "struct BitcoinTx.Info", + "components": [ + { + "name": "version", + "type": "bytes4", + "internalType": "bytes4" + }, + { + "name": "inputVector", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "outputVector", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "locktime", + "type": "bytes4", + "internalType": "bytes4" + } + ] + }, + { + "name": "proof", + "type": "tuple", + "internalType": "struct BitcoinTx.Proof", + "components": [ + { + "name": "merkleProof", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "txIndexInBlock", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "bitcoinHeaders", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "coinbasePreimage", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "coinbaseProof", + "type": "bytes", + "internalType": "bytes" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "withdrawOrdinalSellOrder", + "inputs": [ + { + "name": "id", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "event", + "name": "acceptOrdinalSellOrderEvent", + "inputs": [ + { + "name": "id", + "type": "uint256", + "indexed": true, + "internalType": "uint256" + }, + { + "name": "acceptId", + "type": "uint256", + "indexed": true, + "internalType": "uint256" + }, + { + "name": "bitcoinAddress", + "type": "tuple", + "indexed": false, + "internalType": "struct OrdMarketplace.BitcoinAddress", + "components": [ + { + "name": "scriptPubKey", + "type": "bytes", + "internalType": "bytes" + } + ] + }, + { + "name": "ercToken", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "ercAmount", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "cancelAcceptedOrdinalSellOrderEvent", + "inputs": [ + { + "name": "id", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "placeOrdinalSellOrderEvent", + "inputs": [ + { + "name": "orderId", + "type": "uint256", + "indexed": true, + "internalType": "uint256" + }, + { + "name": "ordinalID", + "type": "tuple", + "indexed": false, + "internalType": "struct OrdMarketplace.OrdinalId", + "components": [ + { + "name": "txId", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "index", + "type": "uint32", + "internalType": "uint32" + } + ] + }, + { + "name": "sellToken", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "sellAmount", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "proofOrdinalSellOrderEvent", + "inputs": [ + { + "name": "id", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "withdrawOrdinalSellOrderEvent", + "inputs": [ + { + "name": "id", + "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 OrdMarketplace { + use super::*; + use alloy::sol_types as 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[P`@Qa>\x158\x03\x80a>\x15\x839\x81\x01`@\x81\x90R`+\x91`PV[`\x03\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x83\x16\x17\x90UP`\x01`\x04U`{V[_` \x82\x84\x03\x12\x15`_W__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14`tW__\xFD[\x93\x92PPPV[a=\x8D\x80a\0\x88_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xB9W_5`\xE0\x1C\x80c\\\x9D\xDC\x84\x11a\0rW\x80c\xD1\x92\x0F\xF0\x11a\0XW\x80c\xD1\x92\x0F\xF0\x14a\x02\x13W\x80c\xDB\x82\xD5\xFA\x14a\x02\x1CW\x80c\xE4\xAEa\xDD\x14a\x02BW__\xFD[\x80c\\\x9D\xDC\x84\x14a\x01\xEDW\x80csxqU\x14a\x02\0W__\xFD[\x80c+&\x0F\xA0\x11a\0\xA2W\x80c+&\x0F\xA0\x14a\0\xFDW\x80c-sY\xC6\x14a\x01\xC2W\x80c=_\xFD[PPPPa\x08>`\x04T\x85a\x08!\x90a7yV[a\x08*\x86a8'V[`\x03T`\x01`\x01`\xA0\x1B\x03\x16\x92\x91\x90a\x14UV[Pa\x08\xC4a\x08O` \x86\x01\x86a6\xD1V[\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\x91RPP`@\x80Q``\x81\x01\x82R`\x04\x87\x01T\x81R`\x05\x87\x01Tc\xFF\xFF\xFF\xFF\x81\x16` \x83\x01Rd\x01\0\0\0\0\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91\x81\x01\x91\x90\x91R\x91Pa\x14\x82\x90PV[a\x08\xD1\x82`\x01\x01\x85a\x16\x83V[`\x04\x82\x01T`\x03\x83\x01T`\x02\x84\x01Ta\x08\xF8\x92`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x92\x91\x16\x90a\x17\nV[\x81T_\x90\x81R` \x81\x81R`@\x80\x83 \x83\x81U`\x01\x80\x82\x01\x80Tc\xFF\xFF\xFF\xFF\x19\x16\x90U`\x02\x82\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`\x03\x82\x01\x85\x90U`\x04\x82\x01\x85\x90U`\x05\x82\x01\x80T\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\x90U`\x06\x90\x91\x01\x80T\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\0\x16\x90U\x88\x84R\x91\x82\x90R\x82 \x82\x81U\x91\x90\x82\x01\x81a\t\xC3\x82\x82a-\xE8V[PPP`\x02\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\x90\x81\x16\x90\x91U_`\x03\x83\x01\x81\x90U`\x04\x83\x01\x80T\x83\x16\x90U`\x05\x83\x01\x80T\x90\x92\x16\x90\x91U`\x06\x90\x91\x01U`@Q\x85\x81R\x7F\xC5w0\x9A\xCDy9\xCC/\x01\xF6\x7F\x07>\x1AT\x82$EL\xDD\xDCy\xB1a\xDB\x17\xB51^\x9F\x0C\x90` \x01`@Q\x80\x91\x03\x90\xA1PPPPPV[``\x80_\x80[`\x02T\x81\x10\x15a\n\x8DW_\x81\x81R`\x01` R`@\x90 `\x03\x01T\x15a\n\x85W\x81a\n\x81\x81a38V[\x92PP[`\x01\x01a\nWV[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xA8Wa\n\xA8a3PV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\n\xE1W\x81` \x01[a\n\xCEa.\"V[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\n\xC6W\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xFEWa\n\xFEa3PV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0B'W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x02T\x81\x10\x15a\x04\xC3W_\x81\x81R`\x01` R`@\x90 `\x03\x01T\x15a\x0C\xA1W`\x01_\x82\x81R` \x01\x90\x81R` \x01_ `@Q\x80`\xE0\x01`@R\x90\x81_\x82\x01T\x81R` \x01`\x01\x82\x01`@Q\x80` \x01`@R\x90\x81_\x82\x01\x80Ta\x0B\x91\x90a4\xBFV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\xBD\x90a4\xBFV[\x80\x15a\x0C\x08W\x80`\x1F\x10a\x0B\xDFWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C\x08V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xEBW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP\x81R`\x02\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16` \x83\x01R`\x03\x83\x01T`@\x83\x01R`\x04\x83\x01T\x81\x16``\x83\x01R`\x05\x83\x01T\x16`\x80\x82\x01R`\x06\x90\x91\x01T`\xA0\x90\x91\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x0CjWa\x0Cja3}V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x0C\x88Wa\x0C\x88a3}V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x0C\x9D\x81a38V[\x92PP[`\x01\x01a\x0B-V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x0C\xFFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FInvalid buying token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05EV[_\x81\x11a\rtW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FBuying amount should be greater `D\x82\x01R\x7Fthan 0\0\0\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\x05EV[`\x02\x80T_\x91\x82a\r\x84\x83a38V[\x91\x90PU\x90P`@Q\x80`\xC0\x01`@R\x80\x86\x806\x03\x81\x01\x90a\r\xA6\x91\x90a8\xE7V[\x81R`\x01`\x01`\xA0\x1B\x03\x85\x16` \x82\x01R`@\x81\x01\x84\x90R``\x01a\r\xD06\x87\x90\x03\x87\x01\x87a9;V[\x81R3` \x80\x83\x01\x91\x90\x91R_`@\x92\x83\x01\x81\x90R\x84\x81R\x80\x82R\x82\x90 \x83Q\x80Q\x82U\x82\x01Q`\x01\x82\x01\x80Tc\xFF\xFF\xFF\xFF\x92\x83\x16c\xFF\xFF\xFF\xFF\x19\x90\x91\x16\x17\x90U\x84\x83\x01Q`\x02\x83\x01\x80T`\x01`\x01`\xA0\x1B\x03\x92\x83\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\x90\x91\x16\x17\x90U\x85\x85\x01Q`\x03\x84\x01U``\x86\x01Q\x80Q`\x04\x85\x01U\x93\x84\x01Q`\x05\x84\x01\x80T\x95\x87\x01Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16d\x01\0\0\0\0\x02\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\x90\x96\x16\x91\x90\x93\x16\x17\x93\x90\x93\x17\x90U`\x80\x84\x01Q`\x06\x90\x91\x01\x80T`\xA0\x90\x95\x01Q\x15\x15t\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\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x95\x16\x91\x90\x92\x16\x17\x92\x90\x92\x17\x90\x91UQ\x81\x90\x7F\xFB-3\x10\xE3\xE7\x95x\xACP|\xDB\xDB2\xE5%\x81\xDB\xC1{\xE0NQ\x97\xD3\xB7\xC5\"s_\xB9\xE4\x90a\x0F?\x90\x88\x90\x87\x90\x87\x90a9\xAEV[`@Q\x80\x91\x03\x90\xA2PPPPPV[_\x81\x81R`\x01` R`@\x90 `\x06\x81\x01Ta\x0Fm\x90aT`\x90a9\xE7V[B\x11a\x0F\xBBW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FRequest still valid\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05EV[`\x05\x81\x01T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x10\x17W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7FSender not the acceptor\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05EV[`\x03\x81\x01T`\x02\x82\x01Ta\x108\x91`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x903\x90a\x17\nV[_\x82\x81R`\x01` \x81\x90R`@\x82 \x82\x81U\x91\x90\x82\x01\x81a\x10Y\x82\x82a-\xE8V[PPP`\x02\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\x90\x81\x16\x90\x91U_`\x03\x83\x01\x81\x90U`\x04\x83\x01\x80T\x83\x16\x90U`\x05\x83\x01\x80T\x90\x92\x16\x90\x91U`\x06\x90\x91\x01U`@Q\x82\x81R\x7F\x9C!jF\x17\xD6\xC0=\xC7\xCB\xD9c!f\xF1\xC5\xC9\xEFA\xF9\xEE\x86\xBF;\x83\xF6q\xC0\x05\x10w\x04\x90` \x01[`@Q\x80\x91\x03\x90\xA1PPV[`\x01` \x81\x81R_\x92\x83R`@\x92\x83\x90 \x80T\x84Q\x92\x83\x01\x90\x94R\x91\x82\x01\x80T\x82\x90\x82\x90a\x11\x12\x90a4\xBFV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x11>\x90a4\xBFV[\x80\x15a\x11\x89W\x80`\x1F\x10a\x11`Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x11\x89V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x11lW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP`\x02\x82\x01T`\x03\x83\x01T`\x04\x84\x01T`\x05\x85\x01T`\x06\x90\x95\x01T\x93\x94`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x94\x92\x93\x91\x82\x16\x92\x91\x16\x90\x87V[_\x81\x81R` \x81\x90R`@\x90 `\x06\x81\x01T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x120W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FSender not the requester\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05EV[`\x06\x81\x01Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x12\xC3W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FOrder has already been accepted,`D\x82\x01R\x7F cannot withdraw\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05EV[_\x82\x81R` \x81\x81R`@\x80\x83 \x83\x81U`\x01\x81\x01\x80Tc\xFF\xFF\xFF\xFF\x19\x16\x90U`\x02\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`\x03\x81\x01\x84\x90U`\x04\x81\x01\x93\x90\x93U`\x05\x83\x01\x80T\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\x90U`\x06\x90\x92\x01\x80T\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\0\x16\x90U\x90Q\x83\x81R\x7F\xB3[?\xE4\xDA\xAFl\xC6n\xB8\xBDA>\x9A\xB5DI\xE7f\xF6\xD4a%\xCCX\xF2UiJ\x0E\x84~\x91\x01a\x10\xD9V[`@Q`\x01`\x01`\xA0\x1B\x03\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x14O\x90\x85\x90\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\x90`\x84\x01[`@\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\x17XV[PPPPV[_a\x14_\x83a\x18=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1B\x08\x91\x90a;qV[`\x80\x84\x01Q\x90\x91Pa\x1B\x1E\x90\x82\x90\x84\x90_a#3V[a\x14OW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`?`$\x82\x01R\x7FCoinbase merkle proof is not val`D\x82\x01R\x7Fid for provided header and hash\0`d\x82\x01R`\x84\x01a\x05EV[_\x83`\x01`\x01`\xA0\x1B\x03\x16c\x117d\xBE`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1B\xCDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1B\xF1\x91\x90a;qV[\x90P_\x84`\x01`\x01`\xA0\x1B\x03\x16c+\x97\xBE$`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1C0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1CT\x91\x90a;qV[\x90P_\x80a\x1Cia\x1Cd\x86a#eV[a#pV[\x90P\x83\x81\x03a\x1CzW\x83\x91Pa\x1C\xF7V[\x82\x81\x03a\x1C\x89W\x82\x91Pa\x1C\xF7V[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`%`$\x82\x01R\x7FNot at current or previous diffi`D\x82\x01R\x7Fculty\0\0\0\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\x05EV[_a\x1D\x01\x86a#\x97V[\x90P_\x19\x81\x03a\x1DyW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`#`$\x82\x01R\x7FInvalid length of the headers ch`D\x82\x01R\x7Fain\0\0\0\0\0\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\x05EV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81\x03a\x1D\xE8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FInvalid headers chain\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05EV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFD\x81\x03a\x1EWW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FInsufficient work in a header\0\0\0`D\x82\x01R`d\x01a\x05EV[a\x1Ea\x87\x84a;\x88V[\x81\x10\x15a\x1E\xD6W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FInsufficient accumulated difficu`D\x82\x01R\x7Flty in header chain\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05EV[PPPPPPPPV[__a\x1E\xEC\x83_a%\xBBV[\x91P\x91P\x91P\x91V[`@\x80Q` \x80\x82R\x81\x83\x01\x90\x92R_\x91\x82\x91\x90` \x82\x01\x81\x806\x837\x01\x90PP\x90P_[` \x81\x10\x15a\x1F\x97W\x83\x81` \x81\x10a\x1F5Wa\x1F5a3}V[\x1A`\xF8\x1B\x82`\x01a\x1FG\x84` a;\x9FV[a\x1FQ\x91\x90a;\x9FV[\x81Q\x81\x10a\x1FaWa\x1Faa3}V[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SP`\x01\x01a\x1F\x1AV[P` \x01Q\x92\x91PPV[_a\x1F\xB0\x83\x83\x01` \x01Q\x90V[\x93\x92PPPV[_a\x1F\xB0a\x1F\xC6\x83` a9\xE7V[\x84\x90a\x1F\xA2V[___a\x1F\xDA\x85\x85a'2V[\x90\x92P\x90P`\x01\x82\x01a\x1F\xF2W_\x19\x92PPPa\x07$V[\x80a\x1F\xFE\x83`%a9\xE7V[a \x08\x91\x90a9\xE7V[a \x13\x90`\x04a9\xE7V[\x95\x94PPPPPV[`@\x80Q``\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x82\x84\x01\x82\x90R\x83Q\x80\x85\x01\x90\x94R\x81\x84R\x83\x01R\x90a P\x84a\x1E\xE0V[` \x83\x01R\x80\x82R\x81a b\x82a38V[\x90RP_\x80[\x82` \x01Q\x81\x10\x15a!dW\x82Q_\x90a \x83\x90\x88\x90a'uV[\x84Q\x90\x91P_\x90a \x95\x90\x89\x90a'\xD0V[\x90P_a \xA3`\x08\x84a;\x9FV[\x86Q\x90\x91P_\x90a \xB5\x90`\x08a9\xE7V[\x8A\x81\x01` \x01\x83\x90 \x90\x91P\x80\x8A\x03a \xEFW`\x01\x96P\x83\x89_\x01\x81\x81Qa \xDD\x91\x90a;\xB2V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RPa!?V[_a \xFD\x8C\x8A_\x01Qa(FV[\x90P`\x01`\x01`\xA0\x1B\x03\x81\x16\x15a!\x1EW`\x01`\x01`\xA0\x1B\x03\x81\x16` \x8B\x01R[_a!,\x8D\x8B_\x01Qa)&V[\x90P\x80\x15a!a+/V[``\x91P[P\x91P\x91Pa+?\x82\x82\x86a-eV[\x97\x96PPPPPPPV[_` \x84Qa+Y\x91\x90a;\xFFV[\x15a+eWP_a\x14zV[\x83Q_\x03a+tWP_a\x14zV[\x81\x85_[\x86Q\x81\x10\x15a+\xE2Wa+\x8C`\x02\x84a;\xFFV[`\x01\x03a+\xB0Wa+\xA9a+\xA3\x88\x83\x01` \x01Q\x90V[\x83a-\x9EV[\x91Pa+\xC9V[a+\xC6\x82a+\xC1\x89\x84\x01` \x01Q\x90V[a-\x9EV[\x91P[`\x01\x92\x90\x92\x1C\x91a+\xDB` \x82a9\xE7V[\x90Pa+xV[P\x90\x93\x14\x95\x94PPPPPV[_\x80a,\x06a+\xFF\x84`Ha9\xE7V[\x85\x90a\x1F\xA2V[`\xE8\x1C\x90P_\x84a,\x18\x85`Ka9\xE7V[\x81Q\x81\x10a,(Wa,(a3}V[\x01` \x01Q`\xF8\x1C\x90P_a,Z\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a,m`\x03\x84a<+V[`\xFF\x16\x90Pa,~\x81a\x01\0a='V[a+?\x90\x83a;\x88V[_a\x1F\xB0\x82\x84a=2V[_\x80a,\x9F\x85\x85a-\xA9V[\x90P\x82\x81\x14a,\xB1W_\x91PPa\x1F\xB0V[P`\x01\x94\x93PPPPV[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x82\x82\x81Q\x81\x10a,\xF4Wa,\xF4a3}V[\x01` \x01Q`\xF8\x1C`\xFF\x03a-\x0BWP`\x08a\x07$V[\x82\x82\x81Q\x81\x10a-\x1DWa-\x1Da3}V[\x01` \x01Q`\xF8\x1C`\xFE\x03a-4WP`\x04a\x07$V[\x82\x82\x81Q\x81\x10a-FWa-Fa3}V[\x01` \x01Q`\xF8\x1C`\xFD\x03a-]WP`\x02a\x07$V[P_\x92\x91PPV[``\x83\x15a-tWP\x81a\x1F\xB0V[\x82Q\x15a-\x84W\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x05E\x91\x90a=EV[_a\x1F\xB0\x83\x83a-\xC1V[_a\x1F\xB0a-\xB8\x83`\x04a9\xE7V[\x84\x01` \x01Q\x90V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[P\x80Ta-\xF4\x90a4\xBFV[_\x82U\x80`\x1F\x10a.\x03WPPV[`\x1F\x01` \x90\x04\x90_R` _ \x90\x81\x01\x90a.\x1F\x91\x90a.qV[PV[`@Q\x80`\xE0\x01`@R\x80_\x81R` \x01a.I`@Q\x80` \x01`@R\x80``\x81RP\x90V[\x81R_` \x82\x01\x81\x90R`@\x82\x01\x81\x90R``\x82\x01\x81\x90R`\x80\x82\x01\x81\x90R`\xA0\x90\x91\x01R\x90V[[\x80\x82\x11\x15a.\x85W_\x81U`\x01\x01a.rV[P\x90V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a.\xB9W\x81Q\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a.\x9BV[P\x93\x94\x93PPPPV[`@\x80\x82R\x83Q\x90\x82\x01\x81\x90R_\x90` \x85\x01\x90``\x84\x01\x90\x83[\x81\x81\x10\x15a/\x8CW\x83Qa/\x03\x84\x82Q\x80Q\x82R` \x90\x81\x01Qc\xFF\xFF\xFF\xFF\x16\x91\x01RV[`\x01`\x01`\xA0\x1B\x03` \x82\x01Q\x16`@\x85\x01R`@\x81\x01Q``\x85\x01R``\x81\x01Qa/V`\x80\x86\x01\x82\x80Q\x82R` \x80\x82\x01Qc\xFF\xFF\xFF\xFF\x16\x90\x83\x01R`@\x90\x81\x01Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91\x01RV[P`\x80\x81\x01Q`\x01`\x01`\xA0\x1B\x03\x16`\xE0\x85\x01R`\xA0\x01Q\x15\x15a\x01\0\x84\x01R` \x93\x90\x93\x01\x92a\x01 \x90\x92\x01\x91`\x01\x01a.\xDEV[PP\x83\x81\x03` \x85\x01Ra/\xA0\x81\x86a.\x89V[\x96\x95PPPPPPV[__`@\x83\x85\x03\x12\x15a/\xBBW__\xFD[\x825\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a/\xD8W__\xFD[\x83\x01` \x81\x86\x03\x12\x15a/\xE9W__\xFD[\x80\x91PP\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a0\x04W__\xFD[P5\x91\x90PV[\x86Q\x81R` \x80\x88\x01Qc\xFF\xFF\xFF\xFF\x16\x90\x82\x01Ra\x01 \x81\x01`\x01`\x01`\xA0\x1B\x03\x87\x16`@\x83\x01R\x85``\x83\x01Ra0j`\x80\x83\x01\x86\x80Q\x82R` \x80\x82\x01Qc\xFF\xFF\xFF\xFF\x16\x90\x83\x01R`@\x90\x81\x01Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91\x01RV[`\x01`\x01`\xA0\x1B\x03\x84\x16`\xE0\x83\x01R\x82\x15\x15a\x01\0\x83\x01R\x97\x96PPPPPPPV[___``\x84\x86\x03\x12\x15a0\x9FW__\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a0\xBCW__\xFD[\x84\x01`\x80\x81\x87\x03\x12\x15a0\xCDW__\xFD[\x91P`@\x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a0\xE8W__\xFD[\x84\x01`\xA0\x81\x87\x03\x12\x15a0\xF9W__\xFD[\x80\x91PP\x92P\x92P\x92V[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_\x81Q` \x84Ra\x14z` \x85\x01\x82a1\x04V[_`@\x82\x01`@\x83R\x80\x85Q\x80\x83R``\x85\x01\x91P``\x81`\x05\x1B\x86\x01\x01\x92P` \x87\x01_[\x82\x81\x10\x15a2%W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x87\x86\x03\x01\x84R\x81Q\x80Q\x86R` \x81\x01Q`\xE0` \x88\x01Ra1\xBA`\xE0\x88\x01\x82a12V[\x90P`\x01`\x01`\xA0\x1B\x03`@\x83\x01Q\x16`@\x88\x01R``\x82\x01Q``\x88\x01R`\x01`\x01`\xA0\x1B\x03`\x80\x83\x01Q\x16`\x80\x88\x01R`\x01`\x01`\xA0\x1B\x03`\xA0\x83\x01Q\x16`\xA0\x88\x01R`\xC0\x82\x01Q`\xC0\x88\x01R\x80\x96PPP` \x82\x01\x91P` \x84\x01\x93P`\x01\x81\x01\x90Pa1lV[PPPP\x82\x81\x03` \x84\x01Ra \x13\x81\x85a.\x89V[____\x84\x86\x03`\xE0\x81\x12\x15a2OW__\xFD[`@\x81\x12\x15a2\\W__\xFD[\x85\x94P``\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x82\x01\x12\x15a2\x8EW__\xFD[P`@\x85\x01\x92P`\xA0\x85\x015`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a2\xAEW__\xFD[\x93\x96\x92\x95P\x92\x93`\xC0\x015\x92PPV[\x87\x81R`\xE0` \x82\x01R_a2\xD6`\xE0\x83\x01\x89a12V[`\x01`\x01`\xA0\x1B\x03\x97\x88\x16`@\x84\x01R``\x83\x01\x96\x90\x96RP\x92\x85\x16`\x80\x84\x01R\x93\x16`\xA0\x82\x01R`\xC0\x01\x91\x90\x91R\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[__\x19\x82\x03a3IWa3Ia3\x0BV[P`\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`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`\xA0\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a3\xCDWa3\xCDa3PV[`@R\x90V[_\x82`\x1F\x83\x01\x12a3\xE2W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a3\xFCWa3\xFCa3PV[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a4+Wa4+a3PV[`@R\x81\x81R\x83\x82\x01` \x01\x85\x10\x15a4BW__\xFD[\x81` \x85\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[_` \x826\x03\x12\x15a4nW__\xFD[`@Q` \x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a4\x91Wa4\x91a3PV[`@R\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a4\xAAW__\xFD[a4\xB66\x82\x86\x01a3\xD3V[\x82RP\x92\x91PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a4\xD3W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a5\nW\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[P\x91\x90PV[`\x1F\x82\x11\x15a\x17SW\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a55WP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a5TW_\x81U`\x01\x01a5AV[PPPPPV[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a5uWa5ua3PV[a5\x89\x81a5\x83\x84Ta4\xBFV[\x84a5\x10V[` `\x1F\x82\x11`\x01\x81\x14a5\xBBW_\x83\x15a5\xA4WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua5TV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a5\xEAW\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a5\xCAV[P\x84\x82\x10\x15a6\x07W\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[\x81\x83R\x81\x81` \x85\x017P_` \x82\x84\x01\x01R_` `\x1F\x19`\x1F\x84\x01\x16\x84\x01\x01\x90P\x92\x91PPV[``\x81R_\x845\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x866\x03\x01\x81\x12a6uW__\xFD[\x85\x01` \x81\x01\x905g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a6\x91W__\xFD[\x806\x03\x82\x13\x15a6\x9FW__\xFD[` ``\x85\x01Ra6\xB4`\x80\x85\x01\x82\x84a6\x16V[`\x01`\x01`\xA0\x1B\x03\x96\x90\x96\x16` \x85\x01RPPP`@\x01R\x91\x90PV[__\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\x12a7\x04W__\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a7\x1EW__\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a'+W__\xFD[` \x81R_a\x14z` \x83\x01\x84\x86a6\x16V[\x805\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\x14a7tW__\xFD[\x91\x90PV[_`\x80\x826\x03\x12\x15a7\x89W__\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a7\xACWa7\xACa3PV[`@Ra7\xB8\x83a7EV[\x81R` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a7\xD3W__\xFD[a7\xDF6\x82\x86\x01a3\xD3V[` \x83\x01RP`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a7\xFEW__\xFD[a8\n6\x82\x86\x01a3\xD3V[`@\x83\x01RPa8\x1C``\x84\x01a7EV[``\x82\x01R\x92\x91PPV[_`\xA0\x826\x03\x12\x15a87W__\xFD[a8?a3\xAAV[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a8UW__\xFD[a8a6\x82\x86\x01a3\xD3V[\x82RP` \x83\x81\x015\x90\x82\x01R`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a8\x87W__\xFD[a8\x936\x82\x86\x01a3\xD3V[`@\x83\x01RP``\x83\x81\x015\x90\x82\x01R`\x80\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a8\xBCW__\xFD[a8\xC86\x82\x86\x01a3\xD3V[`\x80\x83\x01RP\x92\x91PPV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a7tW__\xFD[_`@\x82\x84\x03\x12\x80\x15a8\xF8W__\xFD[P`@\x80Q\x90\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a9\x1CWa9\x1Ca3PV[`@R\x825\x81Ra9/` \x84\x01a8\xD4V[` \x82\x01R\x93\x92PPPV[_``\x82\x84\x03\x12\x80\x15a9LW__\xFD[P`@Q``\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a9pWa9pa3PV[`@R\x825\x81Ra9\x83` \x84\x01a8\xD4V[` \x82\x01R`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a9\xA2W__\xFD[`@\x82\x01R\x93\x92PPPV[\x835\x81R`\x80\x81\x01c\xFF\xFF\xFF\xFFa9\xC7` \x87\x01a8\xD4V[\x16` \x83\x01R`\x01`\x01`\xA0\x1B\x03\x93\x90\x93\x16`@\x82\x01R``\x01R\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x07$Wa\x07$a3\x0BV[\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\x83`\xF8\x1B\x16\x81R__\x83Ta:/\x81a4\xBFV[`\x01\x82\x16\x80\x15a:FW`\x01\x81\x14a:\x7FWa:\xB5V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x83\x16`\x01\x87\x01R`\x01\x82\x15\x15\x83\x02\x87\x01\x01\x93Pa:\xB5V[\x86_R` _ _[\x83\x81\x10\x15a:\xAAW\x81T`\x01\x82\x8A\x01\x01R`\x01\x82\x01\x91P` \x81\x01\x90Pa:\x88V[PP`\x01\x82\x87\x01\x01\x93P[P\x91\x96\x95PPPPPPV[_` \x82\x84\x03\x12\x15a:\xD1W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x1F\xB0W__\xFD[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[\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\x85\x16\x81R_a;3a;-`\x04\x84\x01\x87a:\xE0V[\x85a:\xE0V[\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\x93\x90\x93\x16\x83RPP`\x04\x01\x93\x92PPPV[_a\x1F\xB0\x82\x84a:\xE0V[_` \x82\x84\x03\x12\x15a;\x81W__\xFD[PQ\x91\x90PV[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x07$Wa\x07$a3\x0BV[\x81\x81\x03\x81\x81\x11\x15a\x07$Wa\x07$a3\x0BV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x07$Wa\x07$a3\x0BV[\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<\rWa<\ra;\xD2V[P\x06\x90V[`\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x07$Wa\x07$a3\x0BV[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x07$Wa\x07$a3\x0BV[`\x01\x81[`\x01\x84\x11\x15a<\x7FW\x80\x85\x04\x81\x11\x15a=_\xFD[PPPPa\x08>`\x04T\x85a\x08!\x90a7yV[a\x08*\x86a8'V[`\x03T`\x01`\x01`\xA0\x1B\x03\x16\x92\x91\x90a\x14UV[Pa\x08\xC4a\x08O` \x86\x01\x86a6\xD1V[\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\x91RPP`@\x80Q``\x81\x01\x82R`\x04\x87\x01T\x81R`\x05\x87\x01Tc\xFF\xFF\xFF\xFF\x81\x16` \x83\x01Rd\x01\0\0\0\0\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91\x81\x01\x91\x90\x91R\x91Pa\x14\x82\x90PV[a\x08\xD1\x82`\x01\x01\x85a\x16\x83V[`\x04\x82\x01T`\x03\x83\x01T`\x02\x84\x01Ta\x08\xF8\x92`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x92\x91\x16\x90a\x17\nV[\x81T_\x90\x81R` \x81\x81R`@\x80\x83 \x83\x81U`\x01\x80\x82\x01\x80Tc\xFF\xFF\xFF\xFF\x19\x16\x90U`\x02\x82\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`\x03\x82\x01\x85\x90U`\x04\x82\x01\x85\x90U`\x05\x82\x01\x80T\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\x90U`\x06\x90\x91\x01\x80T\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\0\x16\x90U\x88\x84R\x91\x82\x90R\x82 \x82\x81U\x91\x90\x82\x01\x81a\t\xC3\x82\x82a-\xE8V[PPP`\x02\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\x90\x81\x16\x90\x91U_`\x03\x83\x01\x81\x90U`\x04\x83\x01\x80T\x83\x16\x90U`\x05\x83\x01\x80T\x90\x92\x16\x90\x91U`\x06\x90\x91\x01U`@Q\x85\x81R\x7F\xC5w0\x9A\xCDy9\xCC/\x01\xF6\x7F\x07>\x1AT\x82$EL\xDD\xDCy\xB1a\xDB\x17\xB51^\x9F\x0C\x90` \x01`@Q\x80\x91\x03\x90\xA1PPPPPV[``\x80_\x80[`\x02T\x81\x10\x15a\n\x8DW_\x81\x81R`\x01` R`@\x90 `\x03\x01T\x15a\n\x85W\x81a\n\x81\x81a38V[\x92PP[`\x01\x01a\nWV[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xA8Wa\n\xA8a3PV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\n\xE1W\x81` \x01[a\n\xCEa.\"V[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\n\xC6W\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xFEWa\n\xFEa3PV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0B'W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x02T\x81\x10\x15a\x04\xC3W_\x81\x81R`\x01` R`@\x90 `\x03\x01T\x15a\x0C\xA1W`\x01_\x82\x81R` \x01\x90\x81R` \x01_ `@Q\x80`\xE0\x01`@R\x90\x81_\x82\x01T\x81R` \x01`\x01\x82\x01`@Q\x80` \x01`@R\x90\x81_\x82\x01\x80Ta\x0B\x91\x90a4\xBFV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\xBD\x90a4\xBFV[\x80\x15a\x0C\x08W\x80`\x1F\x10a\x0B\xDFWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C\x08V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xEBW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP\x81R`\x02\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16` \x83\x01R`\x03\x83\x01T`@\x83\x01R`\x04\x83\x01T\x81\x16``\x83\x01R`\x05\x83\x01T\x16`\x80\x82\x01R`\x06\x90\x91\x01T`\xA0\x90\x91\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x0CjWa\x0Cja3}V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x0C\x88Wa\x0C\x88a3}V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x0C\x9D\x81a38V[\x92PP[`\x01\x01a\x0B-V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x0C\xFFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FInvalid buying token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05EV[_\x81\x11a\rtW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FBuying amount should be greater `D\x82\x01R\x7Fthan 0\0\0\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\x05EV[`\x02\x80T_\x91\x82a\r\x84\x83a38V[\x91\x90PU\x90P`@Q\x80`\xC0\x01`@R\x80\x86\x806\x03\x81\x01\x90a\r\xA6\x91\x90a8\xE7V[\x81R`\x01`\x01`\xA0\x1B\x03\x85\x16` \x82\x01R`@\x81\x01\x84\x90R``\x01a\r\xD06\x87\x90\x03\x87\x01\x87a9;V[\x81R3` \x80\x83\x01\x91\x90\x91R_`@\x92\x83\x01\x81\x90R\x84\x81R\x80\x82R\x82\x90 \x83Q\x80Q\x82U\x82\x01Q`\x01\x82\x01\x80Tc\xFF\xFF\xFF\xFF\x92\x83\x16c\xFF\xFF\xFF\xFF\x19\x90\x91\x16\x17\x90U\x84\x83\x01Q`\x02\x83\x01\x80T`\x01`\x01`\xA0\x1B\x03\x92\x83\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\x90\x91\x16\x17\x90U\x85\x85\x01Q`\x03\x84\x01U``\x86\x01Q\x80Q`\x04\x85\x01U\x93\x84\x01Q`\x05\x84\x01\x80T\x95\x87\x01Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16d\x01\0\0\0\0\x02\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\x90\x96\x16\x91\x90\x93\x16\x17\x93\x90\x93\x17\x90U`\x80\x84\x01Q`\x06\x90\x91\x01\x80T`\xA0\x90\x95\x01Q\x15\x15t\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\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x95\x16\x91\x90\x92\x16\x17\x92\x90\x92\x17\x90\x91UQ\x81\x90\x7F\xFB-3\x10\xE3\xE7\x95x\xACP|\xDB\xDB2\xE5%\x81\xDB\xC1{\xE0NQ\x97\xD3\xB7\xC5\"s_\xB9\xE4\x90a\x0F?\x90\x88\x90\x87\x90\x87\x90a9\xAEV[`@Q\x80\x91\x03\x90\xA2PPPPPV[_\x81\x81R`\x01` R`@\x90 `\x06\x81\x01Ta\x0Fm\x90aT`\x90a9\xE7V[B\x11a\x0F\xBBW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FRequest still valid\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05EV[`\x05\x81\x01T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x10\x17W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7FSender not the acceptor\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05EV[`\x03\x81\x01T`\x02\x82\x01Ta\x108\x91`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x903\x90a\x17\nV[_\x82\x81R`\x01` \x81\x90R`@\x82 \x82\x81U\x91\x90\x82\x01\x81a\x10Y\x82\x82a-\xE8V[PPP`\x02\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\x90\x81\x16\x90\x91U_`\x03\x83\x01\x81\x90U`\x04\x83\x01\x80T\x83\x16\x90U`\x05\x83\x01\x80T\x90\x92\x16\x90\x91U`\x06\x90\x91\x01U`@Q\x82\x81R\x7F\x9C!jF\x17\xD6\xC0=\xC7\xCB\xD9c!f\xF1\xC5\xC9\xEFA\xF9\xEE\x86\xBF;\x83\xF6q\xC0\x05\x10w\x04\x90` \x01[`@Q\x80\x91\x03\x90\xA1PPV[`\x01` \x81\x81R_\x92\x83R`@\x92\x83\x90 \x80T\x84Q\x92\x83\x01\x90\x94R\x91\x82\x01\x80T\x82\x90\x82\x90a\x11\x12\x90a4\xBFV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x11>\x90a4\xBFV[\x80\x15a\x11\x89W\x80`\x1F\x10a\x11`Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x11\x89V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x11lW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP`\x02\x82\x01T`\x03\x83\x01T`\x04\x84\x01T`\x05\x85\x01T`\x06\x90\x95\x01T\x93\x94`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x94\x92\x93\x91\x82\x16\x92\x91\x16\x90\x87V[_\x81\x81R` \x81\x90R`@\x90 `\x06\x81\x01T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x120W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FSender not the requester\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05EV[`\x06\x81\x01Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x12\xC3W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FOrder has already been accepted,`D\x82\x01R\x7F cannot withdraw\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05EV[_\x82\x81R` \x81\x81R`@\x80\x83 \x83\x81U`\x01\x81\x01\x80Tc\xFF\xFF\xFF\xFF\x19\x16\x90U`\x02\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`\x03\x81\x01\x84\x90U`\x04\x81\x01\x93\x90\x93U`\x05\x83\x01\x80T\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\x90U`\x06\x90\x92\x01\x80T\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\0\x16\x90U\x90Q\x83\x81R\x7F\xB3[?\xE4\xDA\xAFl\xC6n\xB8\xBDA>\x9A\xB5DI\xE7f\xF6\xD4a%\xCCX\xF2UiJ\x0E\x84~\x91\x01a\x10\xD9V[`@Q`\x01`\x01`\xA0\x1B\x03\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x14O\x90\x85\x90\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\x90`\x84\x01[`@\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\x17XV[PPPPV[_a\x14_\x83a\x18=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1B\x08\x91\x90a;qV[`\x80\x84\x01Q\x90\x91Pa\x1B\x1E\x90\x82\x90\x84\x90_a#3V[a\x14OW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`?`$\x82\x01R\x7FCoinbase merkle proof is not val`D\x82\x01R\x7Fid for provided header and hash\0`d\x82\x01R`\x84\x01a\x05EV[_\x83`\x01`\x01`\xA0\x1B\x03\x16c\x117d\xBE`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1B\xCDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1B\xF1\x91\x90a;qV[\x90P_\x84`\x01`\x01`\xA0\x1B\x03\x16c+\x97\xBE$`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1C0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1CT\x91\x90a;qV[\x90P_\x80a\x1Cia\x1Cd\x86a#eV[a#pV[\x90P\x83\x81\x03a\x1CzW\x83\x91Pa\x1C\xF7V[\x82\x81\x03a\x1C\x89W\x82\x91Pa\x1C\xF7V[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`%`$\x82\x01R\x7FNot at current or previous diffi`D\x82\x01R\x7Fculty\0\0\0\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\x05EV[_a\x1D\x01\x86a#\x97V[\x90P_\x19\x81\x03a\x1DyW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`#`$\x82\x01R\x7FInvalid length of the headers ch`D\x82\x01R\x7Fain\0\0\0\0\0\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\x05EV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81\x03a\x1D\xE8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FInvalid headers chain\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05EV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFD\x81\x03a\x1EWW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FInsufficient work in a header\0\0\0`D\x82\x01R`d\x01a\x05EV[a\x1Ea\x87\x84a;\x88V[\x81\x10\x15a\x1E\xD6W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FInsufficient accumulated difficu`D\x82\x01R\x7Flty in header chain\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05EV[PPPPPPPPV[__a\x1E\xEC\x83_a%\xBBV[\x91P\x91P\x91P\x91V[`@\x80Q` \x80\x82R\x81\x83\x01\x90\x92R_\x91\x82\x91\x90` \x82\x01\x81\x806\x837\x01\x90PP\x90P_[` \x81\x10\x15a\x1F\x97W\x83\x81` \x81\x10a\x1F5Wa\x1F5a3}V[\x1A`\xF8\x1B\x82`\x01a\x1FG\x84` a;\x9FV[a\x1FQ\x91\x90a;\x9FV[\x81Q\x81\x10a\x1FaWa\x1Faa3}V[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SP`\x01\x01a\x1F\x1AV[P` \x01Q\x92\x91PPV[_a\x1F\xB0\x83\x83\x01` \x01Q\x90V[\x93\x92PPPV[_a\x1F\xB0a\x1F\xC6\x83` a9\xE7V[\x84\x90a\x1F\xA2V[___a\x1F\xDA\x85\x85a'2V[\x90\x92P\x90P`\x01\x82\x01a\x1F\xF2W_\x19\x92PPPa\x07$V[\x80a\x1F\xFE\x83`%a9\xE7V[a \x08\x91\x90a9\xE7V[a \x13\x90`\x04a9\xE7V[\x95\x94PPPPPV[`@\x80Q``\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x82\x84\x01\x82\x90R\x83Q\x80\x85\x01\x90\x94R\x81\x84R\x83\x01R\x90a P\x84a\x1E\xE0V[` \x83\x01R\x80\x82R\x81a b\x82a38V[\x90RP_\x80[\x82` \x01Q\x81\x10\x15a!dW\x82Q_\x90a \x83\x90\x88\x90a'uV[\x84Q\x90\x91P_\x90a \x95\x90\x89\x90a'\xD0V[\x90P_a \xA3`\x08\x84a;\x9FV[\x86Q\x90\x91P_\x90a \xB5\x90`\x08a9\xE7V[\x8A\x81\x01` \x01\x83\x90 \x90\x91P\x80\x8A\x03a \xEFW`\x01\x96P\x83\x89_\x01\x81\x81Qa \xDD\x91\x90a;\xB2V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RPa!?V[_a \xFD\x8C\x8A_\x01Qa(FV[\x90P`\x01`\x01`\xA0\x1B\x03\x81\x16\x15a!\x1EW`\x01`\x01`\xA0\x1B\x03\x81\x16` \x8B\x01R[_a!,\x8D\x8B_\x01Qa)&V[\x90P\x80\x15a!a+/V[``\x91P[P\x91P\x91Pa+?\x82\x82\x86a-eV[\x97\x96PPPPPPPV[_` \x84Qa+Y\x91\x90a;\xFFV[\x15a+eWP_a\x14zV[\x83Q_\x03a+tWP_a\x14zV[\x81\x85_[\x86Q\x81\x10\x15a+\xE2Wa+\x8C`\x02\x84a;\xFFV[`\x01\x03a+\xB0Wa+\xA9a+\xA3\x88\x83\x01` \x01Q\x90V[\x83a-\x9EV[\x91Pa+\xC9V[a+\xC6\x82a+\xC1\x89\x84\x01` \x01Q\x90V[a-\x9EV[\x91P[`\x01\x92\x90\x92\x1C\x91a+\xDB` \x82a9\xE7V[\x90Pa+xV[P\x90\x93\x14\x95\x94PPPPPV[_\x80a,\x06a+\xFF\x84`Ha9\xE7V[\x85\x90a\x1F\xA2V[`\xE8\x1C\x90P_\x84a,\x18\x85`Ka9\xE7V[\x81Q\x81\x10a,(Wa,(a3}V[\x01` \x01Q`\xF8\x1C\x90P_a,Z\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a,m`\x03\x84a<+V[`\xFF\x16\x90Pa,~\x81a\x01\0a='V[a+?\x90\x83a;\x88V[_a\x1F\xB0\x82\x84a=2V[_\x80a,\x9F\x85\x85a-\xA9V[\x90P\x82\x81\x14a,\xB1W_\x91PPa\x1F\xB0V[P`\x01\x94\x93PPPPV[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x82\x82\x81Q\x81\x10a,\xF4Wa,\xF4a3}V[\x01` \x01Q`\xF8\x1C`\xFF\x03a-\x0BWP`\x08a\x07$V[\x82\x82\x81Q\x81\x10a-\x1DWa-\x1Da3}V[\x01` \x01Q`\xF8\x1C`\xFE\x03a-4WP`\x04a\x07$V[\x82\x82\x81Q\x81\x10a-FWa-Fa3}V[\x01` \x01Q`\xF8\x1C`\xFD\x03a-]WP`\x02a\x07$V[P_\x92\x91PPV[``\x83\x15a-tWP\x81a\x1F\xB0V[\x82Q\x15a-\x84W\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x05E\x91\x90a=EV[_a\x1F\xB0\x83\x83a-\xC1V[_a\x1F\xB0a-\xB8\x83`\x04a9\xE7V[\x84\x01` \x01Q\x90V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[P\x80Ta-\xF4\x90a4\xBFV[_\x82U\x80`\x1F\x10a.\x03WPPV[`\x1F\x01` \x90\x04\x90_R` _ \x90\x81\x01\x90a.\x1F\x91\x90a.qV[PV[`@Q\x80`\xE0\x01`@R\x80_\x81R` \x01a.I`@Q\x80` \x01`@R\x80``\x81RP\x90V[\x81R_` \x82\x01\x81\x90R`@\x82\x01\x81\x90R``\x82\x01\x81\x90R`\x80\x82\x01\x81\x90R`\xA0\x90\x91\x01R\x90V[[\x80\x82\x11\x15a.\x85W_\x81U`\x01\x01a.rV[P\x90V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a.\xB9W\x81Q\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a.\x9BV[P\x93\x94\x93PPPPV[`@\x80\x82R\x83Q\x90\x82\x01\x81\x90R_\x90` \x85\x01\x90``\x84\x01\x90\x83[\x81\x81\x10\x15a/\x8CW\x83Qa/\x03\x84\x82Q\x80Q\x82R` \x90\x81\x01Qc\xFF\xFF\xFF\xFF\x16\x91\x01RV[`\x01`\x01`\xA0\x1B\x03` \x82\x01Q\x16`@\x85\x01R`@\x81\x01Q``\x85\x01R``\x81\x01Qa/V`\x80\x86\x01\x82\x80Q\x82R` \x80\x82\x01Qc\xFF\xFF\xFF\xFF\x16\x90\x83\x01R`@\x90\x81\x01Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91\x01RV[P`\x80\x81\x01Q`\x01`\x01`\xA0\x1B\x03\x16`\xE0\x85\x01R`\xA0\x01Q\x15\x15a\x01\0\x84\x01R` \x93\x90\x93\x01\x92a\x01 \x90\x92\x01\x91`\x01\x01a.\xDEV[PP\x83\x81\x03` \x85\x01Ra/\xA0\x81\x86a.\x89V[\x96\x95PPPPPPV[__`@\x83\x85\x03\x12\x15a/\xBBW__\xFD[\x825\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a/\xD8W__\xFD[\x83\x01` \x81\x86\x03\x12\x15a/\xE9W__\xFD[\x80\x91PP\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a0\x04W__\xFD[P5\x91\x90PV[\x86Q\x81R` \x80\x88\x01Qc\xFF\xFF\xFF\xFF\x16\x90\x82\x01Ra\x01 \x81\x01`\x01`\x01`\xA0\x1B\x03\x87\x16`@\x83\x01R\x85``\x83\x01Ra0j`\x80\x83\x01\x86\x80Q\x82R` \x80\x82\x01Qc\xFF\xFF\xFF\xFF\x16\x90\x83\x01R`@\x90\x81\x01Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91\x01RV[`\x01`\x01`\xA0\x1B\x03\x84\x16`\xE0\x83\x01R\x82\x15\x15a\x01\0\x83\x01R\x97\x96PPPPPPPV[___``\x84\x86\x03\x12\x15a0\x9FW__\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a0\xBCW__\xFD[\x84\x01`\x80\x81\x87\x03\x12\x15a0\xCDW__\xFD[\x91P`@\x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a0\xE8W__\xFD[\x84\x01`\xA0\x81\x87\x03\x12\x15a0\xF9W__\xFD[\x80\x91PP\x92P\x92P\x92V[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_\x81Q` \x84Ra\x14z` \x85\x01\x82a1\x04V[_`@\x82\x01`@\x83R\x80\x85Q\x80\x83R``\x85\x01\x91P``\x81`\x05\x1B\x86\x01\x01\x92P` \x87\x01_[\x82\x81\x10\x15a2%W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x87\x86\x03\x01\x84R\x81Q\x80Q\x86R` \x81\x01Q`\xE0` \x88\x01Ra1\xBA`\xE0\x88\x01\x82a12V[\x90P`\x01`\x01`\xA0\x1B\x03`@\x83\x01Q\x16`@\x88\x01R``\x82\x01Q``\x88\x01R`\x01`\x01`\xA0\x1B\x03`\x80\x83\x01Q\x16`\x80\x88\x01R`\x01`\x01`\xA0\x1B\x03`\xA0\x83\x01Q\x16`\xA0\x88\x01R`\xC0\x82\x01Q`\xC0\x88\x01R\x80\x96PPP` \x82\x01\x91P` \x84\x01\x93P`\x01\x81\x01\x90Pa1lV[PPPP\x82\x81\x03` \x84\x01Ra \x13\x81\x85a.\x89V[____\x84\x86\x03`\xE0\x81\x12\x15a2OW__\xFD[`@\x81\x12\x15a2\\W__\xFD[\x85\x94P``\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x82\x01\x12\x15a2\x8EW__\xFD[P`@\x85\x01\x92P`\xA0\x85\x015`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a2\xAEW__\xFD[\x93\x96\x92\x95P\x92\x93`\xC0\x015\x92PPV[\x87\x81R`\xE0` \x82\x01R_a2\xD6`\xE0\x83\x01\x89a12V[`\x01`\x01`\xA0\x1B\x03\x97\x88\x16`@\x84\x01R``\x83\x01\x96\x90\x96RP\x92\x85\x16`\x80\x84\x01R\x93\x16`\xA0\x82\x01R`\xC0\x01\x91\x90\x91R\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[__\x19\x82\x03a3IWa3Ia3\x0BV[P`\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`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`\xA0\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a3\xCDWa3\xCDa3PV[`@R\x90V[_\x82`\x1F\x83\x01\x12a3\xE2W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a3\xFCWa3\xFCa3PV[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a4+Wa4+a3PV[`@R\x81\x81R\x83\x82\x01` \x01\x85\x10\x15a4BW__\xFD[\x81` \x85\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[_` \x826\x03\x12\x15a4nW__\xFD[`@Q` \x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a4\x91Wa4\x91a3PV[`@R\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a4\xAAW__\xFD[a4\xB66\x82\x86\x01a3\xD3V[\x82RP\x92\x91PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a4\xD3W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a5\nW\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[P\x91\x90PV[`\x1F\x82\x11\x15a\x17SW\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a55WP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a5TW_\x81U`\x01\x01a5AV[PPPPPV[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a5uWa5ua3PV[a5\x89\x81a5\x83\x84Ta4\xBFV[\x84a5\x10V[` `\x1F\x82\x11`\x01\x81\x14a5\xBBW_\x83\x15a5\xA4WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua5TV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a5\xEAW\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a5\xCAV[P\x84\x82\x10\x15a6\x07W\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[\x81\x83R\x81\x81` \x85\x017P_` \x82\x84\x01\x01R_` `\x1F\x19`\x1F\x84\x01\x16\x84\x01\x01\x90P\x92\x91PPV[``\x81R_\x845\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x866\x03\x01\x81\x12a6uW__\xFD[\x85\x01` \x81\x01\x905g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a6\x91W__\xFD[\x806\x03\x82\x13\x15a6\x9FW__\xFD[` ``\x85\x01Ra6\xB4`\x80\x85\x01\x82\x84a6\x16V[`\x01`\x01`\xA0\x1B\x03\x96\x90\x96\x16` \x85\x01RPPP`@\x01R\x91\x90PV[__\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\x12a7\x04W__\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a7\x1EW__\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a'+W__\xFD[` \x81R_a\x14z` \x83\x01\x84\x86a6\x16V[\x805\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\x14a7tW__\xFD[\x91\x90PV[_`\x80\x826\x03\x12\x15a7\x89W__\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a7\xACWa7\xACa3PV[`@Ra7\xB8\x83a7EV[\x81R` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a7\xD3W__\xFD[a7\xDF6\x82\x86\x01a3\xD3V[` \x83\x01RP`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a7\xFEW__\xFD[a8\n6\x82\x86\x01a3\xD3V[`@\x83\x01RPa8\x1C``\x84\x01a7EV[``\x82\x01R\x92\x91PPV[_`\xA0\x826\x03\x12\x15a87W__\xFD[a8?a3\xAAV[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a8UW__\xFD[a8a6\x82\x86\x01a3\xD3V[\x82RP` \x83\x81\x015\x90\x82\x01R`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a8\x87W__\xFD[a8\x936\x82\x86\x01a3\xD3V[`@\x83\x01RP``\x83\x81\x015\x90\x82\x01R`\x80\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a8\xBCW__\xFD[a8\xC86\x82\x86\x01a3\xD3V[`\x80\x83\x01RP\x92\x91PPV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a7tW__\xFD[_`@\x82\x84\x03\x12\x80\x15a8\xF8W__\xFD[P`@\x80Q\x90\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a9\x1CWa9\x1Ca3PV[`@R\x825\x81Ra9/` \x84\x01a8\xD4V[` \x82\x01R\x93\x92PPPV[_``\x82\x84\x03\x12\x80\x15a9LW__\xFD[P`@Q``\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a9pWa9pa3PV[`@R\x825\x81Ra9\x83` \x84\x01a8\xD4V[` \x82\x01R`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a9\xA2W__\xFD[`@\x82\x01R\x93\x92PPPV[\x835\x81R`\x80\x81\x01c\xFF\xFF\xFF\xFFa9\xC7` \x87\x01a8\xD4V[\x16` \x83\x01R`\x01`\x01`\xA0\x1B\x03\x93\x90\x93\x16`@\x82\x01R``\x01R\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x07$Wa\x07$a3\x0BV[\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\x83`\xF8\x1B\x16\x81R__\x83Ta:/\x81a4\xBFV[`\x01\x82\x16\x80\x15a:FW`\x01\x81\x14a:\x7FWa:\xB5V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x83\x16`\x01\x87\x01R`\x01\x82\x15\x15\x83\x02\x87\x01\x01\x93Pa:\xB5V[\x86_R` _ _[\x83\x81\x10\x15a:\xAAW\x81T`\x01\x82\x8A\x01\x01R`\x01\x82\x01\x91P` \x81\x01\x90Pa:\x88V[PP`\x01\x82\x87\x01\x01\x93P[P\x91\x96\x95PPPPPPV[_` \x82\x84\x03\x12\x15a:\xD1W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x1F\xB0W__\xFD[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[\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\x85\x16\x81R_a;3a;-`\x04\x84\x01\x87a:\xE0V[\x85a:\xE0V[\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\x93\x90\x93\x16\x83RPP`\x04\x01\x93\x92PPPV[_a\x1F\xB0\x82\x84a:\xE0V[_` \x82\x84\x03\x12\x15a;\x81W__\xFD[PQ\x91\x90PV[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x07$Wa\x07$a3\x0BV[\x81\x81\x03\x81\x81\x11\x15a\x07$Wa\x07$a3\x0BV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x07$Wa\x07$a3\x0BV[\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<\rWa<\ra;\xD2V[P\x06\x90V[`\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x07$Wa\x07$a3\x0BV[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x07$Wa\x07$a3\x0BV[`\x01\x81[`\x01\x84\x11\x15a<\x7FW\x80\x85\x04\x81\x11\x15a::RustType, + #[allow(missing_docs)] + pub ercToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub ercAmount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub requester: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub acceptor: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub acceptTime: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + BitcoinAddress, + 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, + alloy::sol_types::sol_data::Uint<256>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ::RustType, + alloy::sol_types::private::Address, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: AcceptedOrdinalSellOrder) -> Self { + ( + value.orderId, + value.bitcoinAddress, + value.ercToken, + value.ercAmount, + value.requester, + value.acceptor, + value.acceptTime, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for AcceptedOrdinalSellOrder { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + orderId: tuple.0, + bitcoinAddress: tuple.1, + ercToken: tuple.2, + ercAmount: tuple.3, + requester: tuple.4, + acceptor: tuple.5, + acceptTime: tuple.6, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for AcceptedOrdinalSellOrder { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for AcceptedOrdinalSellOrder { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.orderId), + ::tokenize( + &self.bitcoinAddress, + ), + ::tokenize( + &self.ercToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.ercAmount), + ::tokenize( + &self.requester, + ), + ::tokenize( + &self.acceptor, + ), + as alloy_sol_types::SolType>::tokenize(&self.acceptTime), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for AcceptedOrdinalSellOrder { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for AcceptedOrdinalSellOrder { + const NAME: &'static str = "AcceptedOrdinalSellOrder"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "AcceptedOrdinalSellOrder(uint256 orderId,BitcoinAddress bitcoinAddress,address ercToken,uint256 ercAmount,address requester,address acceptor,uint256 acceptTime)", + ) + } + #[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( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + as alloy_sol_types::SolType>::eip712_data_word(&self.orderId) + .0, + ::eip712_data_word( + &self.bitcoinAddress, + ) + .0, + ::eip712_data_word( + &self.ercToken, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.ercAmount) + .0, + ::eip712_data_word( + &self.requester, + ) + .0, + ::eip712_data_word( + &self.acceptor, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.acceptTime) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for AcceptedOrdinalSellOrder { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.orderId, + ) + + ::topic_preimage_length( + &rust.bitcoinAddress, + ) + + ::topic_preimage_length( + &rust.ercToken, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.ercAmount, + ) + + ::topic_preimage_length( + &rust.requester, + ) + + ::topic_preimage_length( + &rust.acceptor, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.acceptTime, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.orderId, + out, + ); + ::encode_topic_preimage( + &rust.bitcoinAddress, + out, + ); + ::encode_topic_preimage( + &rust.ercToken, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.ercAmount, + out, + ); + ::encode_topic_preimage( + &rust.requester, + out, + ); + ::encode_topic_preimage( + &rust.acceptor, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.acceptTime, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct BitcoinAddress { bytes scriptPubKey; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct BitcoinAddress { + #[allow(missing_docs)] + pub scriptPubKey: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: BitcoinAddress) -> Self { + (value.scriptPubKey,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for BitcoinAddress { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { scriptPubKey: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for BitcoinAddress { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for BitcoinAddress { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.scriptPubKey, + ), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for BitcoinAddress { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for BitcoinAddress { + const NAME: &'static str = "BitcoinAddress"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "BitcoinAddress(bytes scriptPubKey)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + ::eip712_data_word( + &self.scriptPubKey, + ) + .0 + .to_vec() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for BitcoinAddress { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.scriptPubKey, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.scriptPubKey, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct OrdinalId { bytes32 txId; uint32 index; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct OrdinalId { + #[allow(missing_docs)] + pub txId: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub index: u32, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<32>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>, u32); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: OrdinalId) -> Self { + (value.txId, value.index) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for OrdinalId { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + txId: tuple.0, + index: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for OrdinalId { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for OrdinalId { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.txId), + as alloy_sol_types::SolType>::tokenize(&self.index), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for OrdinalId { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for OrdinalId { + const NAME: &'static str = "OrdinalId"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "OrdinalId(bytes32 txId,uint32 index)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + as alloy_sol_types::SolType>::eip712_data_word(&self.txId) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.index) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for OrdinalId { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.txId) + + as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.index) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.txId, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.index, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct OrdinalSellOrder { OrdinalId ordinalID; address sellToken; uint256 sellAmount; BitcoinTx.UTXO utxo; address requester; bool isOrderAccepted; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct OrdinalSellOrder { + #[allow(missing_docs)] + pub ordinalID: ::RustType, + #[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 utxo: ::RustType, + #[allow(missing_docs)] + pub requester: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub isOrderAccepted: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + OrdinalId, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + BitcoinTx::UTXO, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Bool, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::Address, + alloy::sol_types::private::primitives::aliases::U256, + ::RustType, + alloy::sol_types::private::Address, + bool, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: OrdinalSellOrder) -> Self { + ( + value.ordinalID, + value.sellToken, + value.sellAmount, + value.utxo, + value.requester, + value.isOrderAccepted, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for OrdinalSellOrder { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + ordinalID: tuple.0, + sellToken: tuple.1, + sellAmount: tuple.2, + utxo: tuple.3, + requester: tuple.4, + isOrderAccepted: tuple.5, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for OrdinalSellOrder { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for OrdinalSellOrder { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize(&self.ordinalID), + ::tokenize( + &self.sellToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.sellAmount), + ::tokenize(&self.utxo), + ::tokenize( + &self.requester, + ), + ::tokenize( + &self.isOrderAccepted, + ), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for OrdinalSellOrder { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for OrdinalSellOrder { + const NAME: &'static str = "OrdinalSellOrder"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "OrdinalSellOrder(OrdinalId ordinalID,address sellToken,uint256 sellAmount,BitcoinTx.UTXO utxo,address requester,bool isOrderAccepted)", + ) + } + #[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(::eip712_root_type()); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.ordinalID, + ) + .0, + ::eip712_data_word( + &self.sellToken, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.sellAmount) + .0, + ::eip712_data_word( + &self.utxo, + ) + .0, + ::eip712_data_word( + &self.requester, + ) + .0, + ::eip712_data_word( + &self.isOrderAccepted, + ) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for OrdinalSellOrder { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.ordinalID, + ) + + ::topic_preimage_length( + &rust.sellToken, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.sellAmount, + ) + + ::topic_preimage_length( + &rust.utxo, + ) + + ::topic_preimage_length( + &rust.requester, + ) + + ::topic_preimage_length( + &rust.isOrderAccepted, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.ordinalID, + out, + ); + ::encode_topic_preimage( + &rust.sellToken, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.sellAmount, + out, + ); + ::encode_topic_preimage( + &rust.utxo, + out, + ); + ::encode_topic_preimage( + &rust.requester, + out, + ); + ::encode_topic_preimage( + &rust.isOrderAccepted, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `acceptOrdinalSellOrderEvent(uint256,uint256,(bytes),address,uint256)` and selector `0xfe350ff9ccadd1b7c26b5f96dd078d08a877c8f37d506931ecd8f2bdbd51b6f2`. +```solidity +event acceptOrdinalSellOrderEvent(uint256 indexed id, uint256 indexed acceptId, BitcoinAddress bitcoinAddress, address ercToken, uint256 ercAmount); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct acceptOrdinalSellOrderEvent { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub acceptId: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub bitcoinAddress: ::RustType, + #[allow(missing_docs)] + pub ercToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub ercAmount: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for acceptOrdinalSellOrderEvent { + type DataTuple<'a> = ( + BitcoinAddress, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + const SIGNATURE: &'static str = "acceptOrdinalSellOrderEvent(uint256,uint256,(bytes),address,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 254u8, 53u8, 15u8, 249u8, 204u8, 173u8, 209u8, 183u8, 194u8, 107u8, 95u8, + 150u8, 221u8, 7u8, 141u8, 8u8, 168u8, 119u8, 200u8, 243u8, 125u8, 80u8, + 105u8, 49u8, 236u8, 216u8, 242u8, 189u8, 189u8, 81u8, 182u8, 242u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + id: topics.1, + acceptId: topics.2, + bitcoinAddress: data.0, + ercToken: data.1, + ercAmount: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.bitcoinAddress, + ), + ::tokenize( + &self.ercToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.ercAmount), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.id.clone(), self.acceptId.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.id); + out[2usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.acceptId); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for acceptOrdinalSellOrderEvent { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&acceptOrdinalSellOrderEvent> for alloy_sol_types::private::LogData { + #[inline] + fn from( + this: &acceptOrdinalSellOrderEvent, + ) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `cancelAcceptedOrdinalSellOrderEvent(uint256)` and selector `0x9c216a4617d6c03dc7cbd9632166f1c5c9ef41f9ee86bf3b83f671c005107704`. +```solidity +event cancelAcceptedOrdinalSellOrderEvent(uint256 id); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct cancelAcceptedOrdinalSellOrderEvent { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for cancelAcceptedOrdinalSellOrderEvent { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "cancelAcceptedOrdinalSellOrderEvent(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 156u8, 33u8, 106u8, 70u8, 23u8, 214u8, 192u8, 61u8, 199u8, 203u8, 217u8, + 99u8, 33u8, 102u8, 241u8, 197u8, 201u8, 239u8, 65u8, 249u8, 238u8, 134u8, + 191u8, 59u8, 131u8, 246u8, 113u8, 192u8, 5u8, 16u8, 119u8, 4u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { id: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 cancelAcceptedOrdinalSellOrderEvent { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&cancelAcceptedOrdinalSellOrderEvent> + for alloy_sol_types::private::LogData { + #[inline] + fn from( + this: &cancelAcceptedOrdinalSellOrderEvent, + ) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `placeOrdinalSellOrderEvent(uint256,(bytes32,uint32),address,uint256)` and selector `0xfb2d3310e3e79578ac507cdbdb32e52581dbc17be04e5197d3b7c522735fb9e4`. +```solidity +event placeOrdinalSellOrderEvent(uint256 indexed orderId, OrdinalId ordinalID, address sellToken, uint256 sellAmount); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct placeOrdinalSellOrderEvent { + #[allow(missing_docs)] + pub orderId: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub ordinalID: ::RustType, + #[allow(missing_docs)] + pub sellToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub sellAmount: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for placeOrdinalSellOrderEvent { + type DataTuple<'a> = ( + OrdinalId, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Uint<256>, + ); + const SIGNATURE: &'static str = "placeOrdinalSellOrderEvent(uint256,(bytes32,uint32),address,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 251u8, 45u8, 51u8, 16u8, 227u8, 231u8, 149u8, 120u8, 172u8, 80u8, 124u8, + 219u8, 219u8, 50u8, 229u8, 37u8, 129u8, 219u8, 193u8, 123u8, 224u8, 78u8, + 81u8, 151u8, 211u8, 183u8, 197u8, 34u8, 115u8, 95u8, 185u8, 228u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + orderId: topics.1, + ordinalID: data.0, + sellToken: data.1, + sellAmount: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize(&self.ordinalID), + ::tokenize( + &self.sellToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.sellAmount), + ) + } + #[inline] + fn topics(&self) -> ::RustType { + (Self::SIGNATURE_HASH.into(), self.orderId.clone()) + } + #[inline] + fn encode_topics_raw( + &self, + out: &mut [alloy_sol_types::abi::token::WordToken], + ) -> alloy_sol_types::Result<()> { + if out.len() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.orderId); + Ok(()) + } + } + #[automatically_derived] + impl alloy_sol_types::private::IntoLogData for placeOrdinalSellOrderEvent { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&placeOrdinalSellOrderEvent> for alloy_sol_types::private::LogData { + #[inline] + fn from( + this: &placeOrdinalSellOrderEvent, + ) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `proofOrdinalSellOrderEvent(uint256)` and selector `0xc577309acd7939cc2f01f67f073e1a548224454cdddc79b161db17b5315e9f0c`. +```solidity +event proofOrdinalSellOrderEvent(uint256 id); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct proofOrdinalSellOrderEvent { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for proofOrdinalSellOrderEvent { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "proofOrdinalSellOrderEvent(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 197u8, 119u8, 48u8, 154u8, 205u8, 121u8, 57u8, 204u8, 47u8, 1u8, 246u8, + 127u8, 7u8, 62u8, 26u8, 84u8, 130u8, 36u8, 69u8, 76u8, 221u8, 220u8, + 121u8, 177u8, 97u8, 219u8, 23u8, 181u8, 49u8, 94u8, 159u8, 12u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { id: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 proofOrdinalSellOrderEvent { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&proofOrdinalSellOrderEvent> for alloy_sol_types::private::LogData { + #[inline] + fn from( + this: &proofOrdinalSellOrderEvent, + ) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `withdrawOrdinalSellOrderEvent(uint256)` and selector `0xb35b3fe4daaf6cc66eb8bd413e9ab54449e766f6d46125cc58f255694a0e847e`. +```solidity +event withdrawOrdinalSellOrderEvent(uint256 id); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct withdrawOrdinalSellOrderEvent { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for withdrawOrdinalSellOrderEvent { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "withdrawOrdinalSellOrderEvent(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 179u8, 91u8, 63u8, 228u8, 218u8, 175u8, 108u8, 198u8, 110u8, 184u8, + 189u8, 65u8, 62u8, 154u8, 181u8, 68u8, 73u8, 231u8, 102u8, 246u8, 212u8, + 97u8, 37u8, 204u8, 88u8, 242u8, 85u8, 105u8, 74u8, 14u8, 132u8, 126u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { id: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 withdrawOrdinalSellOrderEvent { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&withdrawOrdinalSellOrderEvent> for alloy_sol_types::private::LogData { + #[inline] + fn from( + this: &withdrawOrdinalSellOrderEvent, + ) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(address _relay); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _relay: alloy::sol_types::private::Address, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._relay,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _relay: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolConstructor for constructorCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._relay, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `REQUEST_EXPIRATION_SECONDS()` and selector `0xd1920ff0`. +```solidity +function REQUEST_EXPIRATION_SECONDS() external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct REQUEST_EXPIRATION_SECONDSCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`REQUEST_EXPIRATION_SECONDS()`](REQUEST_EXPIRATION_SECONDSCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct REQUEST_EXPIRATION_SECONDSReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: REQUEST_EXPIRATION_SECONDSCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for REQUEST_EXPIRATION_SECONDSCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: REQUEST_EXPIRATION_SECONDSReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for REQUEST_EXPIRATION_SECONDSReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for REQUEST_EXPIRATION_SECONDSCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "REQUEST_EXPIRATION_SECONDS()"; + const SELECTOR: [u8; 4] = [209u8, 146u8, 15u8, 240u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: REQUEST_EXPIRATION_SECONDSReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: REQUEST_EXPIRATION_SECONDSReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `acceptOrdinalSellOrder(uint256,(bytes))` and selector `0x2814a1cd`. +```solidity +function acceptOrdinalSellOrder(uint256 id, BitcoinAddress memory bitcoinAddress) external returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct acceptOrdinalSellOrderCall { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub bitcoinAddress: ::RustType, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`acceptOrdinalSellOrder(uint256,(bytes))`](acceptOrdinalSellOrderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct acceptOrdinalSellOrderReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + BitcoinAddress, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: acceptOrdinalSellOrderCall) -> Self { + (value.id, value.bitcoinAddress) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for acceptOrdinalSellOrderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + id: tuple.0, + bitcoinAddress: tuple.1, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: acceptOrdinalSellOrderReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for acceptOrdinalSellOrderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for acceptOrdinalSellOrderCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + BitcoinAddress, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "acceptOrdinalSellOrder(uint256,(bytes))"; + const SELECTOR: [u8; 4] = [40u8, 20u8, 161u8, 205u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + ::tokenize( + &self.bitcoinAddress, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: acceptOrdinalSellOrderReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: acceptOrdinalSellOrderReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `acceptedOrdinalSellOrders(uint256)` and selector `0xdb82d5fa`. +```solidity +function acceptedOrdinalSellOrders(uint256) external view returns (uint256 orderId, BitcoinAddress memory bitcoinAddress, address ercToken, uint256 ercAmount, address requester, address acceptor, uint256 acceptTime); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct acceptedOrdinalSellOrdersCall( + pub alloy::sol_types::private::primitives::aliases::U256, + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`acceptedOrdinalSellOrders(uint256)`](acceptedOrdinalSellOrdersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct acceptedOrdinalSellOrdersReturn { + #[allow(missing_docs)] + pub orderId: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub bitcoinAddress: ::RustType, + #[allow(missing_docs)] + pub ercToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub ercAmount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub requester: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub acceptor: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub acceptTime: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: acceptedOrdinalSellOrdersCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for acceptedOrdinalSellOrdersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + BitcoinAddress, + 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, + alloy::sol_types::sol_data::Uint<256>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ::RustType, + alloy::sol_types::private::Address, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: acceptedOrdinalSellOrdersReturn) -> Self { + ( + value.orderId, + value.bitcoinAddress, + value.ercToken, + value.ercAmount, + value.requester, + value.acceptor, + value.acceptTime, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for acceptedOrdinalSellOrdersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + orderId: tuple.0, + bitcoinAddress: tuple.1, + ercToken: tuple.2, + ercAmount: tuple.3, + requester: tuple.4, + acceptor: tuple.5, + acceptTime: tuple.6, + } + } + } + } + impl acceptedOrdinalSellOrdersReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + ( + as alloy_sol_types::SolType>::tokenize(&self.orderId), + ::tokenize( + &self.bitcoinAddress, + ), + ::tokenize( + &self.ercToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.ercAmount), + ::tokenize( + &self.requester, + ), + ::tokenize( + &self.acceptor, + ), + as alloy_sol_types::SolType>::tokenize(&self.acceptTime), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for acceptedOrdinalSellOrdersCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = acceptedOrdinalSellOrdersReturn; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + BitcoinAddress, + 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, + alloy::sol_types::sol_data::Uint<256>, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "acceptedOrdinalSellOrders(uint256)"; + const SELECTOR: [u8; 4] = [219u8, 130u8, 213u8, 250u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.0), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + acceptedOrdinalSellOrdersReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `cancelAcceptedOrdinalSellOrder(uint256)` and selector `0x73787155`. +```solidity +function cancelAcceptedOrdinalSellOrder(uint256 id) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct cancelAcceptedOrdinalSellOrderCall { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`cancelAcceptedOrdinalSellOrder(uint256)`](cancelAcceptedOrdinalSellOrderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct cancelAcceptedOrdinalSellOrderReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: cancelAcceptedOrdinalSellOrderCall) -> Self { + (value.id,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for cancelAcceptedOrdinalSellOrderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { id: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: cancelAcceptedOrdinalSellOrderReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for cancelAcceptedOrdinalSellOrderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl cancelAcceptedOrdinalSellOrderReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for cancelAcceptedOrdinalSellOrderCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = cancelAcceptedOrdinalSellOrderReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "cancelAcceptedOrdinalSellOrder(uint256)"; + const SELECTOR: [u8; 4] = [115u8, 120u8, 113u8, 85u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + cancelAcceptedOrdinalSellOrderReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `getOpenAcceptedOrdinalSellOrders()` and selector `0x3c49febe`. +```solidity +function getOpenAcceptedOrdinalSellOrders() external view returns (AcceptedOrdinalSellOrder[] memory, uint256[] memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getOpenAcceptedOrdinalSellOrdersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`getOpenAcceptedOrdinalSellOrders()`](getOpenAcceptedOrdinalSellOrdersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getOpenAcceptedOrdinalSellOrdersReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Vec< + ::RustType, + >, + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getOpenAcceptedOrdinalSellOrdersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getOpenAcceptedOrdinalSellOrdersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getOpenAcceptedOrdinalSellOrdersReturn) -> Self { + (value._0, value._1) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getOpenAcceptedOrdinalSellOrdersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0, _1: tuple.1 } + } + } + } + impl getOpenAcceptedOrdinalSellOrdersReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + , + > as alloy_sol_types::SolType>::tokenize(&self._1), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getOpenAcceptedOrdinalSellOrdersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = getOpenAcceptedOrdinalSellOrdersReturn; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array>, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getOpenAcceptedOrdinalSellOrders()"; + const SELECTOR: [u8; 4] = [60u8, 73u8, 254u8, 190u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + getOpenAcceptedOrdinalSellOrdersReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `getOpenOrdinalSellOrders()` and selector `0x171abce5`. +```solidity +function getOpenOrdinalSellOrders() external view returns (OrdinalSellOrder[] memory, uint256[] memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getOpenOrdinalSellOrdersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`getOpenOrdinalSellOrders()`](getOpenOrdinalSellOrdersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getOpenOrdinalSellOrdersReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Vec< + ::RustType, + >, + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getOpenOrdinalSellOrdersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getOpenOrdinalSellOrdersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getOpenOrdinalSellOrdersReturn) -> Self { + (value._0, value._1) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getOpenOrdinalSellOrdersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0, _1: tuple.1 } + } + } + } + impl getOpenOrdinalSellOrdersReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + , + > as alloy_sol_types::SolType>::tokenize(&self._1), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getOpenOrdinalSellOrdersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = getOpenOrdinalSellOrdersReturn; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array>, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getOpenOrdinalSellOrders()"; + const SELECTOR: [u8; 4] = [23u8, 26u8, 188u8, 229u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + getOpenOrdinalSellOrdersReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `ordinalSellOrders(uint256)` and selector `0x2b260fa0`. +```solidity +function ordinalSellOrders(uint256) external view returns (OrdinalId memory ordinalID, address sellToken, uint256 sellAmount, BitcoinTx.UTXO memory utxo, address requester, bool isOrderAccepted); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ordinalSellOrdersCall( + pub alloy::sol_types::private::primitives::aliases::U256, + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`ordinalSellOrders(uint256)`](ordinalSellOrdersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct ordinalSellOrdersReturn { + #[allow(missing_docs)] + pub ordinalID: ::RustType, + #[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 utxo: ::RustType, + #[allow(missing_docs)] + pub requester: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub isOrderAccepted: bool, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ordinalSellOrdersCall) -> Self { + (value.0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ordinalSellOrdersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self(tuple.0) + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + OrdinalId, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + BitcoinTx::UTXO, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Bool, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + alloy::sol_types::private::Address, + alloy::sol_types::private::primitives::aliases::U256, + ::RustType, + alloy::sol_types::private::Address, + bool, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: ordinalSellOrdersReturn) -> Self { + ( + value.ordinalID, + value.sellToken, + value.sellAmount, + value.utxo, + value.requester, + value.isOrderAccepted, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for ordinalSellOrdersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + ordinalID: tuple.0, + sellToken: tuple.1, + sellAmount: tuple.2, + utxo: tuple.3, + requester: tuple.4, + isOrderAccepted: tuple.5, + } + } + } + } + impl ordinalSellOrdersReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + ( + ::tokenize(&self.ordinalID), + ::tokenize( + &self.sellToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.sellAmount), + ::tokenize(&self.utxo), + ::tokenize( + &self.requester, + ), + ::tokenize( + &self.isOrderAccepted, + ), + ) + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for ordinalSellOrdersCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = ordinalSellOrdersReturn; + type ReturnTuple<'a> = ( + OrdinalId, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + BitcoinTx::UTXO, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Bool, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "ordinalSellOrders(uint256)"; + const SELECTOR: [u8; 4] = [43u8, 38u8, 15u8, 160u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.0), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ordinalSellOrdersReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `placeOrdinalSellOrder((bytes32,uint32),(bytes32,uint32,uint64),address,uint256)` and selector `0x5c9ddc84`. +```solidity +function placeOrdinalSellOrder(OrdinalId memory ordinalID, BitcoinTx.UTXO memory utxo, address sellToken, uint256 sellAmount) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct placeOrdinalSellOrderCall { + #[allow(missing_docs)] + pub ordinalID: ::RustType, + #[allow(missing_docs)] + pub utxo: ::RustType, + #[allow(missing_docs)] + pub sellToken: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub sellAmount: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`placeOrdinalSellOrder((bytes32,uint32),(bytes32,uint32,uint64),address,uint256)`](placeOrdinalSellOrderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct placeOrdinalSellOrderReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + OrdinalId, + BitcoinTx::UTXO, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + ::RustType, + ::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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: placeOrdinalSellOrderCall) -> Self { + (value.ordinalID, value.utxo, value.sellToken, value.sellAmount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for placeOrdinalSellOrderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + ordinalID: tuple.0, + utxo: tuple.1, + sellToken: tuple.2, + sellAmount: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: placeOrdinalSellOrderReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for placeOrdinalSellOrderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl placeOrdinalSellOrderReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for placeOrdinalSellOrderCall { + type Parameters<'a> = ( + OrdinalId, + BitcoinTx::UTXO, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = placeOrdinalSellOrderReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "placeOrdinalSellOrder((bytes32,uint32),(bytes32,uint32,uint64),address,uint256)"; + const SELECTOR: [u8; 4] = [92u8, 157u8, 220u8, 132u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize(&self.ordinalID), + ::tokenize(&self.utxo), + ::tokenize( + &self.sellToken, + ), + as alloy_sol_types::SolType>::tokenize(&self.sellAmount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + placeOrdinalSellOrderReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `proofOrdinalSellOrder(uint256,(bytes4,bytes,bytes,bytes4),(bytes,uint256,bytes,bytes32,bytes))` and selector `0x2d7359c6`. +```solidity +function proofOrdinalSellOrder(uint256 id, BitcoinTx.Info memory transaction, BitcoinTx.Proof memory proof) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proofOrdinalSellOrderCall { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub transaction: ::RustType, + #[allow(missing_docs)] + pub proof: ::RustType, + } + ///Container type for the return parameters of the [`proofOrdinalSellOrder(uint256,(bytes4,bytes,bytes,bytes4),(bytes,uint256,bytes,bytes32,bytes))`](proofOrdinalSellOrderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct proofOrdinalSellOrderReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + BitcoinTx::Info, + BitcoinTx::Proof, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ::RustType, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: proofOrdinalSellOrderCall) -> Self { + (value.id, value.transaction, value.proof) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for proofOrdinalSellOrderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + id: tuple.0, + transaction: tuple.1, + proof: tuple.2, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: proofOrdinalSellOrderReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for proofOrdinalSellOrderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl proofOrdinalSellOrderReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for proofOrdinalSellOrderCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Uint<256>, + BitcoinTx::Info, + BitcoinTx::Proof, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = proofOrdinalSellOrderReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "proofOrdinalSellOrder(uint256,(bytes4,bytes,bytes,bytes4),(bytes,uint256,bytes,bytes32,bytes))"; + const SELECTOR: [u8; 4] = [45u8, 115u8, 89u8, 198u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + ::tokenize( + &self.transaction, + ), + ::tokenize(&self.proof), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + proofOrdinalSellOrderReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `withdrawOrdinalSellOrder(uint256)` and selector `0xe4ae61dd`. +```solidity +function withdrawOrdinalSellOrder(uint256 id) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct withdrawOrdinalSellOrderCall { + #[allow(missing_docs)] + pub id: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`withdrawOrdinalSellOrder(uint256)`](withdrawOrdinalSellOrderCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct withdrawOrdinalSellOrderReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: withdrawOrdinalSellOrderCall) -> Self { + (value.id,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for withdrawOrdinalSellOrderCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { id: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: withdrawOrdinalSellOrderReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for withdrawOrdinalSellOrderReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl withdrawOrdinalSellOrderReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for withdrawOrdinalSellOrderCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = withdrawOrdinalSellOrderReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "withdrawOrdinalSellOrder(uint256)"; + const SELECTOR: [u8; 4] = [228u8, 174u8, 97u8, 221u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.id), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + withdrawOrdinalSellOrderReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + ///Container for all the [`OrdMarketplace`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum OrdMarketplaceCalls { + #[allow(missing_docs)] + REQUEST_EXPIRATION_SECONDS(REQUEST_EXPIRATION_SECONDSCall), + #[allow(missing_docs)] + acceptOrdinalSellOrder(acceptOrdinalSellOrderCall), + #[allow(missing_docs)] + acceptedOrdinalSellOrders(acceptedOrdinalSellOrdersCall), + #[allow(missing_docs)] + cancelAcceptedOrdinalSellOrder(cancelAcceptedOrdinalSellOrderCall), + #[allow(missing_docs)] + getOpenAcceptedOrdinalSellOrders(getOpenAcceptedOrdinalSellOrdersCall), + #[allow(missing_docs)] + getOpenOrdinalSellOrders(getOpenOrdinalSellOrdersCall), + #[allow(missing_docs)] + ordinalSellOrders(ordinalSellOrdersCall), + #[allow(missing_docs)] + placeOrdinalSellOrder(placeOrdinalSellOrderCall), + #[allow(missing_docs)] + proofOrdinalSellOrder(proofOrdinalSellOrderCall), + #[allow(missing_docs)] + withdrawOrdinalSellOrder(withdrawOrdinalSellOrderCall), + } + #[automatically_derived] + impl OrdMarketplaceCalls { + /// 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]] = &[ + [23u8, 26u8, 188u8, 229u8], + [40u8, 20u8, 161u8, 205u8], + [43u8, 38u8, 15u8, 160u8], + [45u8, 115u8, 89u8, 198u8], + [60u8, 73u8, 254u8, 190u8], + [92u8, 157u8, 220u8, 132u8], + [115u8, 120u8, 113u8, 85u8], + [209u8, 146u8, 15u8, 240u8], + [219u8, 130u8, 213u8, 250u8], + [228u8, 174u8, 97u8, 221u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for OrdMarketplaceCalls { + const NAME: &'static str = "OrdMarketplaceCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 10usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::REQUEST_EXPIRATION_SECONDS(_) => { + ::SELECTOR + } + Self::acceptOrdinalSellOrder(_) => { + ::SELECTOR + } + Self::acceptedOrdinalSellOrders(_) => { + ::SELECTOR + } + Self::cancelAcceptedOrdinalSellOrder(_) => { + ::SELECTOR + } + Self::getOpenAcceptedOrdinalSellOrders(_) => { + ::SELECTOR + } + Self::getOpenOrdinalSellOrders(_) => { + ::SELECTOR + } + Self::ordinalSellOrders(_) => { + ::SELECTOR + } + Self::placeOrdinalSellOrder(_) => { + ::SELECTOR + } + Self::proofOrdinalSellOrder(_) => { + ::SELECTOR + } + Self::withdrawOrdinalSellOrder(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn getOpenOrdinalSellOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OrdMarketplaceCalls::getOpenOrdinalSellOrders) + } + getOpenOrdinalSellOrders + }, + { + fn acceptOrdinalSellOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OrdMarketplaceCalls::acceptOrdinalSellOrder) + } + acceptOrdinalSellOrder + }, + { + fn ordinalSellOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OrdMarketplaceCalls::ordinalSellOrders) + } + ordinalSellOrders + }, + { + fn proofOrdinalSellOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OrdMarketplaceCalls::proofOrdinalSellOrder) + } + proofOrdinalSellOrder + }, + { + fn getOpenAcceptedOrdinalSellOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OrdMarketplaceCalls::getOpenAcceptedOrdinalSellOrders) + } + getOpenAcceptedOrdinalSellOrders + }, + { + fn placeOrdinalSellOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OrdMarketplaceCalls::placeOrdinalSellOrder) + } + placeOrdinalSellOrder + }, + { + fn cancelAcceptedOrdinalSellOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OrdMarketplaceCalls::cancelAcceptedOrdinalSellOrder) + } + cancelAcceptedOrdinalSellOrder + }, + { + fn REQUEST_EXPIRATION_SECONDS( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OrdMarketplaceCalls::REQUEST_EXPIRATION_SECONDS) + } + REQUEST_EXPIRATION_SECONDS + }, + { + fn acceptedOrdinalSellOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OrdMarketplaceCalls::acceptedOrdinalSellOrders) + } + acceptedOrdinalSellOrders + }, + { + fn withdrawOrdinalSellOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OrdMarketplaceCalls::withdrawOrdinalSellOrder) + } + withdrawOrdinalSellOrder + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn getOpenOrdinalSellOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OrdMarketplaceCalls::getOpenOrdinalSellOrders) + } + getOpenOrdinalSellOrders + }, + { + fn acceptOrdinalSellOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OrdMarketplaceCalls::acceptOrdinalSellOrder) + } + acceptOrdinalSellOrder + }, + { + fn ordinalSellOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OrdMarketplaceCalls::ordinalSellOrders) + } + ordinalSellOrders + }, + { + fn proofOrdinalSellOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OrdMarketplaceCalls::proofOrdinalSellOrder) + } + proofOrdinalSellOrder + }, + { + fn getOpenAcceptedOrdinalSellOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OrdMarketplaceCalls::getOpenAcceptedOrdinalSellOrders) + } + getOpenAcceptedOrdinalSellOrders + }, + { + fn placeOrdinalSellOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OrdMarketplaceCalls::placeOrdinalSellOrder) + } + placeOrdinalSellOrder + }, + { + fn cancelAcceptedOrdinalSellOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OrdMarketplaceCalls::cancelAcceptedOrdinalSellOrder) + } + cancelAcceptedOrdinalSellOrder + }, + { + fn REQUEST_EXPIRATION_SECONDS( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OrdMarketplaceCalls::REQUEST_EXPIRATION_SECONDS) + } + REQUEST_EXPIRATION_SECONDS + }, + { + fn acceptedOrdinalSellOrders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OrdMarketplaceCalls::acceptedOrdinalSellOrders) + } + acceptedOrdinalSellOrders + }, + { + fn withdrawOrdinalSellOrder( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OrdMarketplaceCalls::withdrawOrdinalSellOrder) + } + withdrawOrdinalSellOrder + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::REQUEST_EXPIRATION_SECONDS(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::acceptOrdinalSellOrder(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::acceptedOrdinalSellOrders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::cancelAcceptedOrdinalSellOrder(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getOpenAcceptedOrdinalSellOrders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::getOpenOrdinalSellOrders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::ordinalSellOrders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::placeOrdinalSellOrder(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::proofOrdinalSellOrder(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::withdrawOrdinalSellOrder(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::REQUEST_EXPIRATION_SECONDS(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::acceptOrdinalSellOrder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::acceptedOrdinalSellOrders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::cancelAcceptedOrdinalSellOrder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getOpenAcceptedOrdinalSellOrders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::getOpenOrdinalSellOrders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::ordinalSellOrders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::placeOrdinalSellOrder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::proofOrdinalSellOrder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::withdrawOrdinalSellOrder(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`OrdMarketplace`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum OrdMarketplaceEvents { + #[allow(missing_docs)] + acceptOrdinalSellOrderEvent(acceptOrdinalSellOrderEvent), + #[allow(missing_docs)] + cancelAcceptedOrdinalSellOrderEvent(cancelAcceptedOrdinalSellOrderEvent), + #[allow(missing_docs)] + placeOrdinalSellOrderEvent(placeOrdinalSellOrderEvent), + #[allow(missing_docs)] + proofOrdinalSellOrderEvent(proofOrdinalSellOrderEvent), + #[allow(missing_docs)] + withdrawOrdinalSellOrderEvent(withdrawOrdinalSellOrderEvent), + } + #[automatically_derived] + impl OrdMarketplaceEvents { + /// 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]] = &[ + [ + 156u8, 33u8, 106u8, 70u8, 23u8, 214u8, 192u8, 61u8, 199u8, 203u8, 217u8, + 99u8, 33u8, 102u8, 241u8, 197u8, 201u8, 239u8, 65u8, 249u8, 238u8, 134u8, + 191u8, 59u8, 131u8, 246u8, 113u8, 192u8, 5u8, 16u8, 119u8, 4u8, + ], + [ + 179u8, 91u8, 63u8, 228u8, 218u8, 175u8, 108u8, 198u8, 110u8, 184u8, + 189u8, 65u8, 62u8, 154u8, 181u8, 68u8, 73u8, 231u8, 102u8, 246u8, 212u8, + 97u8, 37u8, 204u8, 88u8, 242u8, 85u8, 105u8, 74u8, 14u8, 132u8, 126u8, + ], + [ + 197u8, 119u8, 48u8, 154u8, 205u8, 121u8, 57u8, 204u8, 47u8, 1u8, 246u8, + 127u8, 7u8, 62u8, 26u8, 84u8, 130u8, 36u8, 69u8, 76u8, 221u8, 220u8, + 121u8, 177u8, 97u8, 219u8, 23u8, 181u8, 49u8, 94u8, 159u8, 12u8, + ], + [ + 251u8, 45u8, 51u8, 16u8, 227u8, 231u8, 149u8, 120u8, 172u8, 80u8, 124u8, + 219u8, 219u8, 50u8, 229u8, 37u8, 129u8, 219u8, 193u8, 123u8, 224u8, 78u8, + 81u8, 151u8, 211u8, 183u8, 197u8, 34u8, 115u8, 95u8, 185u8, 228u8, + ], + [ + 254u8, 53u8, 15u8, 249u8, 204u8, 173u8, 209u8, 183u8, 194u8, 107u8, 95u8, + 150u8, 221u8, 7u8, 141u8, 8u8, 168u8, 119u8, 200u8, 243u8, 125u8, 80u8, + 105u8, 49u8, 236u8, 216u8, 242u8, 189u8, 189u8, 81u8, 182u8, 242u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for OrdMarketplaceEvents { + const NAME: &'static str = "OrdMarketplaceEvents"; + const COUNT: usize = 5usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::acceptOrdinalSellOrderEvent) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::cancelAcceptedOrdinalSellOrderEvent) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::placeOrdinalSellOrderEvent) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::proofOrdinalSellOrderEvent) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::withdrawOrdinalSellOrderEvent) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 OrdMarketplaceEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::acceptOrdinalSellOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::cancelAcceptedOrdinalSellOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::placeOrdinalSellOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::proofOrdinalSellOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::withdrawOrdinalSellOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::acceptOrdinalSellOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::cancelAcceptedOrdinalSellOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::placeOrdinalSellOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::proofOrdinalSellOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::withdrawOrdinalSellOrderEvent(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`OrdMarketplace`](self) contract instance. + +See the [wrapper's documentation](`OrdMarketplaceInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> OrdMarketplaceInstance { + OrdMarketplaceInstance::::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: alloy_contract::private::Network, + >( + provider: P, + _relay: alloy::sol_types::private::Address, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + OrdMarketplaceInstance::::deploy(provider, _relay) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + _relay: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + OrdMarketplaceInstance::::deploy_builder(provider, _relay) + } + /**A [`OrdMarketplace`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`OrdMarketplace`](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 OrdMarketplaceInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for OrdMarketplaceInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("OrdMarketplaceInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > OrdMarketplaceInstance { + /**Creates a new wrapper around an on-chain [`OrdMarketplace`](self) contract instance. + +See the [wrapper's documentation](`OrdMarketplaceInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + _relay: alloy::sol_types::private::Address, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(provider, _relay); + 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, + _relay: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { _relay }, + )[..], + ] + .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 OrdMarketplaceInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> OrdMarketplaceInstance { + OrdMarketplaceInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > OrdMarketplaceInstance { + /// 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( + &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 [`REQUEST_EXPIRATION_SECONDS`] function. + pub fn REQUEST_EXPIRATION_SECONDS( + &self, + ) -> alloy_contract::SolCallBuilder<&P, REQUEST_EXPIRATION_SECONDSCall, N> { + self.call_builder(&REQUEST_EXPIRATION_SECONDSCall) + } + ///Creates a new call builder for the [`acceptOrdinalSellOrder`] function. + pub fn acceptOrdinalSellOrder( + &self, + id: alloy::sol_types::private::primitives::aliases::U256, + bitcoinAddress: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, acceptOrdinalSellOrderCall, N> { + self.call_builder( + &acceptOrdinalSellOrderCall { + id, + bitcoinAddress, + }, + ) + } + ///Creates a new call builder for the [`acceptedOrdinalSellOrders`] function. + pub fn acceptedOrdinalSellOrders( + &self, + _0: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, acceptedOrdinalSellOrdersCall, N> { + self.call_builder(&acceptedOrdinalSellOrdersCall(_0)) + } + ///Creates a new call builder for the [`cancelAcceptedOrdinalSellOrder`] function. + pub fn cancelAcceptedOrdinalSellOrder( + &self, + id: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, cancelAcceptedOrdinalSellOrderCall, N> { + self.call_builder( + &cancelAcceptedOrdinalSellOrderCall { + id, + }, + ) + } + ///Creates a new call builder for the [`getOpenAcceptedOrdinalSellOrders`] function. + pub fn getOpenAcceptedOrdinalSellOrders( + &self, + ) -> alloy_contract::SolCallBuilder< + &P, + getOpenAcceptedOrdinalSellOrdersCall, + N, + > { + self.call_builder(&getOpenAcceptedOrdinalSellOrdersCall) + } + ///Creates a new call builder for the [`getOpenOrdinalSellOrders`] function. + pub fn getOpenOrdinalSellOrders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, getOpenOrdinalSellOrdersCall, N> { + self.call_builder(&getOpenOrdinalSellOrdersCall) + } + ///Creates a new call builder for the [`ordinalSellOrders`] function. + pub fn ordinalSellOrders( + &self, + _0: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, ordinalSellOrdersCall, N> { + self.call_builder(&ordinalSellOrdersCall(_0)) + } + ///Creates a new call builder for the [`placeOrdinalSellOrder`] function. + pub fn placeOrdinalSellOrder( + &self, + ordinalID: ::RustType, + utxo: ::RustType, + sellToken: alloy::sol_types::private::Address, + sellAmount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, placeOrdinalSellOrderCall, N> { + self.call_builder( + &placeOrdinalSellOrderCall { + ordinalID, + utxo, + sellToken, + sellAmount, + }, + ) + } + ///Creates a new call builder for the [`proofOrdinalSellOrder`] function. + pub fn proofOrdinalSellOrder( + &self, + id: alloy::sol_types::private::primitives::aliases::U256, + transaction: ::RustType, + proof: ::RustType, + ) -> alloy_contract::SolCallBuilder<&P, proofOrdinalSellOrderCall, N> { + self.call_builder( + &proofOrdinalSellOrderCall { + id, + transaction, + proof, + }, + ) + } + ///Creates a new call builder for the [`withdrawOrdinalSellOrder`] function. + pub fn withdrawOrdinalSellOrder( + &self, + id: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, withdrawOrdinalSellOrderCall, N> { + self.call_builder(&withdrawOrdinalSellOrderCall { id }) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > OrdMarketplaceInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`acceptOrdinalSellOrderEvent`] event. + pub fn acceptOrdinalSellOrderEvent_filter( + &self, + ) -> alloy_contract::Event<&P, acceptOrdinalSellOrderEvent, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`cancelAcceptedOrdinalSellOrderEvent`] event. + pub fn cancelAcceptedOrdinalSellOrderEvent_filter( + &self, + ) -> alloy_contract::Event<&P, cancelAcceptedOrdinalSellOrderEvent, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`placeOrdinalSellOrderEvent`] event. + pub fn placeOrdinalSellOrderEvent_filter( + &self, + ) -> alloy_contract::Event<&P, placeOrdinalSellOrderEvent, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`proofOrdinalSellOrderEvent`] event. + pub fn proofOrdinalSellOrderEvent_filter( + &self, + ) -> alloy_contract::Event<&P, proofOrdinalSellOrderEvent, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`withdrawOrdinalSellOrderEvent`] event. + pub fn withdrawOrdinalSellOrderEvent_filter( + &self, + ) -> alloy_contract::Event<&P, withdrawOrdinalSellOrderEvent, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/ownable.rs b/crates/bindings/src/ownable.rs new file mode 100644 index 000000000..7e310370a --- /dev/null +++ b/crates/bindings/src/ownable.rs @@ -0,0 +1,1104 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface Ownable { + event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); + + function owner() external view returns (address); + function renounceOwnership() external; + function transferOwnership(address newOwner) external; +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "owner", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "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": "OwnershipTransferred", + "inputs": [ + { + "name": "previousOwner", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "newOwner", + "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 Ownable { + use super::*; + use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for OwnershipTransferred { + type DataTuple<'a> = (); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = ( + alloy_sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + 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, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + previousOwner: topics.1, + newOwner: topics.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return 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) -> ::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() < ::COUNT { + return Err(alloy_sol_types::Error::Overrun); + } + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); + out[1usize] = ::encode_topic( + &self.previousOwner, + ); + out[2usize] = ::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(serde::Serialize, serde::Deserialize)] + #[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(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ownerCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ownerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: ownerReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for ownerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for ownerCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "owner()"; + const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + 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 { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: ownerReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: renounceOwnershipCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for renounceOwnershipCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: renounceOwnershipReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for renounceOwnershipReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl renounceOwnershipReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for renounceOwnershipCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = renounceOwnershipReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "renounceOwnership()"; + const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8]; + #[inline] + fn new<'a>( + tuple: 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 { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: transferOwnershipCall) -> Self { + (value.newOwner,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for transferOwnershipCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { newOwner: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: transferOwnershipReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for transferOwnershipReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl transferOwnershipReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for transferOwnershipCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = transferOwnershipReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "transferOwnership(address)"; + const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::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 { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + ///Container for all the [`Ownable`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum OwnableCalls { + #[allow(missing_docs)] + owner(ownerCall), + #[allow(missing_docs)] + renounceOwnership(renounceOwnershipCall), + #[allow(missing_docs)] + transferOwnership(transferOwnershipCall), + } + #[automatically_derived] + impl OwnableCalls { + /// 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]] = &[ + [113u8, 80u8, 24u8, 166u8], + [141u8, 165u8, 203u8, 91u8], + [242u8, 253u8, 227u8, 139u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for OwnableCalls { + const NAME: &'static str = "OwnableCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 3usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::owner(_) => ::SELECTOR, + Self::renounceOwnership(_) => { + ::SELECTOR + } + Self::transferOwnership(_) => { + ::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 { + static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result] = &[ + { + fn renounceOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OwnableCalls::renounceOwnership) + } + renounceOwnership + }, + { + fn owner(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(OwnableCalls::owner) + } + owner + }, + { + fn transferOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(OwnableCalls::transferOwnership) + } + transferOwnership + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn renounceOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OwnableCalls::renounceOwnership) + } + renounceOwnership + }, + { + fn owner(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OwnableCalls::owner) + } + owner + }, + { + fn transferOwnership( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(OwnableCalls::transferOwnership) + } + transferOwnership + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::owner(inner) => { + ::abi_encoded_size(inner) + } + Self::renounceOwnership(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::transferOwnership(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::owner(inner) => { + ::abi_encode_raw(inner, out) + } + Self::renounceOwnership(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::transferOwnership(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`Ownable`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum OwnableEvents { + #[allow(missing_docs)] + OwnershipTransferred(OwnershipTransferred), + } + #[automatically_derived] + impl OwnableEvents { + /// 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]] = &[ + [ + 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, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for OwnableEvents { + const NAME: &'static str = "OwnableEvents"; + const COUNT: usize = 1usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::OwnershipTransferred) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 OwnableEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::OwnershipTransferred(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::OwnershipTransferred(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`Ownable`](self) contract instance. + +See the [wrapper's documentation](`OwnableInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >(address: alloy_sol_types::private::Address, provider: P) -> OwnableInstance { + OwnableInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + OwnableInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + OwnableInstance::::deploy_builder(provider) + } + /**A [`Ownable`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`Ownable`](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 OwnableInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for OwnableInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("OwnableInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > OwnableInstance { + /**Creates a new wrapper around an on-chain [`Ownable`](self) contract instance. + +See the [wrapper's documentation](`OwnableInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 OwnableInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> OwnableInstance { + OwnableInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > OwnableInstance { + /// 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( + &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 [`owner`] function. + pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> { + self.call_builder(&ownerCall) + } + ///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. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > OwnableInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`OwnershipTransferred`] event. + pub fn OwnershipTransferred_filter( + &self, + ) -> alloy_contract::Event<&P, OwnershipTransferred, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/fullrelayfindheighttest.rs b/crates/bindings/src/pell_bed_rock_lst_strategy_forked.rs similarity index 63% rename from crates/bindings/src/fullrelayfindheighttest.rs rename to crates/bindings/src/pell_bed_rock_lst_strategy_forked.rs index 76f7f0cd3..fd39807d7 100644 --- a/crates/bindings/src/fullrelayfindheighttest.rs +++ b/crates/bindings/src/pell_bed_rock_lst_strategy_forked.rs @@ -837,7 +837,7 @@ library StdInvariant { } } -interface FullRelayFindHeightTest { +interface PellBedRockLSTStrategyForked { event log(string); event log_address(address); event log_array(uint256[] val); @@ -861,37 +861,28 @@ interface FullRelayFindHeightTest { event log_uint(uint256); event logs(bytes); - constructor(); - function IS_TEST() external view returns (bool); function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); function excludeContracts() external view returns (address[] memory excludedContracts_); function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); function excludeSenders() external view returns (address[] memory excludedSenders_); function failed() external view returns (bool); - function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); - function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); - function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); - function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); + function setUp() external; + function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); function targetArtifacts() external view returns (string[] memory targetedArtifacts_); function targetContracts() external view returns (address[] memory targetedContracts_); function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); function targetSenders() external view returns (address[] memory targetedSenders_); - function testFindHeightOfExistingBlocks() external view; - function testFindUnknownBlock() external; + function testPellBedrockLSTStrategy() external; + function token() external view returns (address); } ``` ...which was generated by the following JSON ABI: ```json [ - { - "type": "constructor", - "inputs": [], - "stateMutability": "nonpayable" - }, { "type": "function", "name": "IS_TEST", @@ -984,119 +975,38 @@ interface FullRelayFindHeightTest { }, { "type": "function", - "name": "getBlockHeights", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getDigestLes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes32[]", - "internalType": "bytes32[]" - } - ], - "stateMutability": "view" + "name": "setUp", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" }, { "type": "function", - "name": "getHeaderHexes", + "name": "simulateForkAndTransfer", "inputs": [ { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", + "name": "forkAtBlock", "type": "uint256", "internalType": "uint256" }, { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes[]", - "internalType": "bytes[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaders", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" + "name": "sender", + "type": "address", + "internalType": "address" }, { - "name": "from", - "type": "uint256", - "internalType": "uint256" + "name": "receiver", + "type": "address", + "internalType": "address" }, { - "name": "to", + "name": "amount", "type": "uint256", "internalType": "uint256" } ], - "outputs": [ - { - "name": "headers", - "type": "bytes", - "internalType": "bytes" - } - ], - "stateMutability": "view" + "outputs": [], + "stateMutability": "nonpayable" }, { "type": "function", @@ -1214,17 +1124,23 @@ interface FullRelayFindHeightTest { }, { "type": "function", - "name": "testFindHeightOfExistingBlocks", + "name": "testPellBedrockLSTStrategy", "inputs": [], "outputs": [], - "stateMutability": "view" + "stateMutability": "nonpayable" }, { "type": "function", - "name": "testFindUnknownBlock", + "name": "token", "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IERC20" + } + ], + "stateMutability": "view" }, { "type": "event", @@ -1599,28 +1515,28 @@ interface FullRelayFindHeightTest { clippy::style, clippy::empty_structs_with_brackets )] -pub mod FullRelayFindHeightTest { +pub mod PellBedRockLSTStrategyForked { use super::*; use alloy::sol_types as alloy_sol_types; /// 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`@R`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15a\0,W__\xFD[P`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k42\xB0\xB22\xB99\x9759\xB7\xB7`\xA1\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k\x05\xCC\xEC\xAD\xCC\xAEm.e\xCD\x0C\xAF`\xA3\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x0F\x81R` \x01n\x0B\x99\xD9[\x99\\\xDA\\\xCB\x9A\x19ZY\xDA\x1D`\x8A\x1B\x81RP`@Q\x80`@\x01`@R\x80` \x81R` \x01\x7F.fakePeriodStartHeader.digest_le\x81RP__Q` aT4_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x16c\xD90\xA0\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\x1EW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01E\x91\x90\x81\x01\x90a\t%V[\x90P_\x81\x86`@Q` \x01a\x01[\x92\x91\x90a\t\x80V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Rc`\xF9\xBB\x11`\xE0\x1B\x82R\x91P_Q` aT4_9_Q\x90_R\x90c`\xF9\xBB\x11\x90a\x01\x9B\x90\x84\x90`\x04\x01a\t\xF2V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xB5W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01\xDC\x91\x90\x81\x01\x90a\t%V[` \x90a\x01\xE9\x90\x82a\n\x88V[Pa\x02\x80\x85` \x80Ta\x01\xFB\x90a\n\x04V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02'\x90a\n\x04V[\x80\x15a\x02rW\x80`\x1F\x10a\x02IWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02rV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02UW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x04\xEE\x91PPV[a\x03\x16\x85` \x80Ta\x02\x91\x90a\n\x04V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\xBD\x90a\n\x04V[\x80\x15a\x03\x08W\x80`\x1F\x10a\x02\xDFWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\x08V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02\xEBW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x05m\x91PPV[a\x03\xAC\x85` \x80Ta\x03'\x90a\n\x04V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03S\x90a\n\x04V[\x80\x15a\x03\x9EW\x80`\x1F\x10a\x03uWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\x9EV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\x81W\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x05\xE0\x91PPV[`@Qa\x03\xB8\x90a\x08\x8FV[a\x03\xC4\x93\x92\x91\x90a\x0BBV[`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03\xDDW=__>=_\xFD[P`\x1F`\x01a\x01\0\n\x81T\x81`\x01`\x01`\xA0\x1B\x03\x02\x19\x16\x90\x83`\x01`\x01`\xA0\x1B\x03\x16\x02\x17\x90UPPPPPPP`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16ce\xDAA\xB9a\x04c`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k\x05\xCC\xEC\xAD\xCC\xAEm.e\xCD\x0C\xAF`\xA3\x1B\x81RP` \x80Ta\x01\xFB\x90a\n\x04V[`@\x80Q\x80\x82\x01\x90\x91R`\x05\x81Rd1\xB40\xB4\xB7`\xD9\x1B` \x82\x01Ra\x04\x8B\x90_`\x06a\x06\x14V[`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x04\xA8\x92\x91\x90a\x0BfV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04\xC4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04\xE8\x91\x90a\x0B\x8AV[Pa\x0C\xC5V[`@Qc\x1F\xB2C}`\xE3\x1B\x81R``\x90_Q` aT4_9_Q\x90_R\x90c\xFD\x92\x1B\xE8\x90a\x05#\x90\x86\x90\x86\x90`\x04\x01a\x0BfV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05=W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x05d\x91\x90\x81\x01\x90a\t%V[\x90P[\x92\x91PPV[`@QcV\xEE\xF1[`\xE1\x1B\x81R_\x90_Q` aT4_9_Q\x90_R\x90c\xAD\xDD\xE2\xB6\x90a\x05\xA1\x90\x86\x90\x86\x90`\x04\x01a\x0BfV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xBCW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05d\x91\x90a\x0B\xB0V[`@Qc\x17w\xE5\x9D`\xE0\x1B\x81R_\x90_Q` aT4_9_Q\x90_R\x90c\x17w\xE5\x9D\x90a\x05\xA1\x90\x86\x90\x86\x90`\x04\x01a\x0BfV[``_a\x06\"\x85\x85\x85a\x06\x86V[\x90P_[a\x060\x85\x85a\x0B\xDBV[\x81\x10\x15a\x06}W\x82\x82\x82\x81Q\x81\x10a\x06JWa\x06Ja\x0B\xEEV[` \x02` \x01\x01Q`@Q` \x01a\x06c\x92\x91\x90a\x0C\x02V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x06&V[PP\x93\x92PPPV[``a\x06\xB5\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01b\r\x0C\xAF`\xEB\x1B\x81RPa\x06\xBD` \x1B` \x1CV[\x94\x93PPPPV[``a\x06\xC9\x84\x84a\x0B\xDBV[`\x01`\x01`@\x1B\x03\x81\x11\x15a\x06\xE0Wa\x06\xE0a\x08\x9CV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x07\x13W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x06\xFEW\x90P[P\x90P\x83[\x83\x81\x10\x15a\x07\x8AWa\x07\\\x86a\x07-\x83a\x07\x93V[\x85`@Q` \x01a\x07@\x93\x92\x91\x90a\x0C\x16V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x01\xFB\x90a\n\x04V[\x82a\x07g\x87\x84a\x0B\xDBV[\x81Q\x81\x10a\x07wWa\x07wa\x0B\xEEV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x07\x18V[P\x94\x93PPPPV[``\x81_\x03a\x07\xB9WPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R`\x03`\xFC\x1B` \x82\x01R\x90V[\x81_[\x81\x15a\x07\xE2W\x80a\x07\xCC\x81a\x0C`V[\x91Pa\x07\xDB\x90P`\n\x83a\x0C\x8CV[\x91Pa\x07\xBCV[_\x81`\x01`\x01`@\x1B\x03\x81\x11\x15a\x07\xFBWa\x07\xFBa\x08\x9CV[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x08%W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x06\xB5Wa\x08:`\x01\x83a\x0B\xDBV[\x91Pa\x08G`\n\x86a\x0C\x9FV[a\x08R\x90`0a\x0C\xB2V[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x08gWa\x08ga\x0B\xEEV[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SPa\x08\x88`\n\x86a\x0C\x8CV[\x94Pa\x08)V[a);\x80a*\xF9\x839\x01\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x80`\x01`\x01`@\x1B\x03\x84\x11\x15a\x08\xC9Wa\x08\xC9a\x08\x9CV[P`@Q`\x1F\x19`\x1F\x85\x01\x81\x16`?\x01\x16\x81\x01\x81\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17\x15a\x08\xF7Wa\x08\xF7a\x08\x9CV[`@R\x83\x81R\x90P\x80\x82\x84\x01\x85\x10\x15a\t\x0EW__\xFD[\x83\x83` \x83\x01^_` \x85\x83\x01\x01RP\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\t5W__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\tJW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\tZW__\xFD[a\x06\xB5\x84\x82Q` \x84\x01a\x08\xB0V[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\t\x8B\x82\x85a\tiV[\x7F/test/fullRelay/testData/\0\0\0\0\0\0\0\x81Ra\t\xBB`\x19\x82\x01\x85a\tiV[\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R_a\x05d` \x83\x01\x84a\t\xC4V[`\x01\x81\x81\x1C\x90\x82\x16\x80a\n\x18W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\n6WcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\n\x83W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\naWP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\n\x80W_\x81U`\x01\x01a\nmV[PP[PPPV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\n\xA1Wa\n\xA1a\x08\x9CV[a\n\xB5\x81a\n\xAF\x84Ta\n\x04V[\x84a\n^<#\x11a\x01\x02W\x80cD\xBA\xDB\xB6\x11a\0\xE8W\x80cD\xBA\xDB\xB6\x14a\x01\xB6W\x80cf\xD9\xA9\xA0\x14a\x01\xD6W\x80c\x85\"l\x81\x14a\x01\xEBW__\xFD[\x80c>^<#\x14a\x01\xA6W\x80c?r\x86\xF4\x14a\x01\xAEW__\xFD[\x80c\x08\x13\x85*\x14a\x013W\x80c\x1C\r\xA8\x1F\x14a\x01\\W\x80c\x1E\xD7\x83\x1C\x14a\x01|W\x80c*\xDE8\x80\x14a\x01\x91W[__\xFD[a\x01Fa\x01A6`\x04a\x17\x0EV[a\x02wV[`@Qa\x01S\x91\x90a\x17\xC3V[`@Q\x80\x91\x03\x90\xF3[a\x01oa\x01j6`\x04a\x17\x0EV[a\x02\xC2V[`@Qa\x01S\x91\x90a\x18&V[a\x01\x84a\x034V[`@Qa\x01S\x91\x90a\x188V[a\x01\x99a\x03\xA1V[`@Qa\x01S\x91\x90a\x18\xEAV[a\x01\x84a\x04\xEAV[a\x01\x84a\x05UV[a\x01\xC9a\x01\xC46`\x04a\x17\x0EV[a\x05\xC0V[`@Qa\x01S\x91\x90a\x19nV[a\x01\xDEa\x06\x03V[`@Qa\x01S\x91\x90a\x1A\x01V[a\x01\xF3a\x07|V[`@Qa\x01S\x91\x90a\x1A\x7FV[a\x02\x08a\x08GV[`@Qa\x01S\x91\x90a\x1A\x91V[a\x02\x08a\tJV[a\x01\xF3a\nMV[a\x02-a\x0B\x18V[`@Q\x90\x15\x15\x81R` \x01a\x01SV[a\x02Ea\x0B\xE8V[\0[a\x01\x84a\r-V[a\x02Ea\r\x98V[`\x1FTa\x02-\x90`\xFF\x16\x81V[a\x01\xC9a\x02r6`\x04a\x17\x0EV[a\x0F\x0FV[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x0FRV[\x94\x93PPPPV[``_a\x02\xD0\x85\x85\x85a\x02wV[\x90P_[a\x02\xDE\x85\x85a\x1BBV[\x81\x10\x15a\x03+W\x82\x82\x82\x81Q\x81\x10a\x02\xF8Wa\x02\xF8a\x1BUV[` \x02` \x01\x01Q`@Q` \x01a\x03\x11\x92\x91\x90a\x1B\x99V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x02\xD4V[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\xCAW\x83\x82\x90_R` _ \x01\x80Ta\x04?\x90a\x1B\xADV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x04k\x90a\x1B\xADV[\x80\x15a\x04\xB6W\x80`\x1F\x10a\x04\x8DWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x04\xB6V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x04\x99W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x04\"V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x03\xC4V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x10\xB3V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x06V\x90a\x1B\xADV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06\x82\x90a\x1B\xADV[\x80\x15a\x06\xCDW\x80`\x1F\x10a\x06\xA4Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x06\xCDV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x06\xB0W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07dW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x07\x11W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x06&V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x01\x80Ta\x07\xBC\x90a\x1B\xADV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07\xE8\x90a\x1B\xADV[\x80\x15a\x083W\x80`\x1F\x10a\x08\nWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x083V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x08\x16W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x07\x9FV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\t2W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x08\xDFW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x08jV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\n5W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\t\xE2W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\tmV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x01\x80Ta\n\x8D\x90a\x1B\xADV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n\xB9\x90a\x1B\xADV[\x80\x15a\x0B\x04W\x80`\x1F\x10a\n\xDBWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\x04V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\n\xE7W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\npV[`\x08T_\x90`\xFF\x16\x15a\x0B/WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0B\xBDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\xE1\x91\x90a\x1B\xFEV[\x14\x15\x90P\x90V[`@\x80Q\x80\x82\x01\x82R`\r\x81R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x0Ci\x91\x90`\x04\x01a\x18&V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0C\x80W__\xFD[PZ\xF1\x15\x80\x15a\x0C\x92W=__>=_\xFD[PP`\x1FT`@Q\x7F`\xB5\xC3\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\x82\x01Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92Pc`\xB5\xC3\x90\x91P`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\r\x06W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r*\x91\x90a\x1B\xFEV[PV[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[_a\r\xDA`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01\x7Fchain\0\0\0\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_`\x06a\x05\xC0V[\x90P_a\x0E\x1E`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01\x7Fchain\0\0\0\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_`\x06a\x0F\x0FV[\x90P_[`\x06\x81\x10\x15a\x0F\nWa\x0F\x02`\x1F`\x01\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`\xB5\xC3\x90\x85\x84\x81Q\x81\x10a\x0E~Wa\x0E~a\x1BUV[` \x02` \x01\x01Q`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0E\xA4\x91\x81R` \x01\x90V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\xBFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\xE3\x91\x90a\x1B\xFEV[\x83\x83\x81Q\x81\x10a\x0E\xF5Wa\x0E\xF5a\x1BUV[` \x02` \x01\x01Qa\x12\x01V[`\x01\x01a\x0E\"V[PPPV[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x12\x84V[``a\x0F^\x84\x84a\x1BBV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0FvWa\x0Fva\x16\x89V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0F\xA9W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x0F\x94W\x90P[P\x90P\x83[\x83\x81\x10\x15a\x10\xAAWa\x10|\x86a\x0F\xC3\x83a\x13\xD2V[\x85`@Q` \x01a\x0F\xD6\x93\x92\x91\x90a\x1C\x15V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x0F\xF2\x90a\x1B\xADV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x10\x1E\x90a\x1B\xADV[\x80\x15a\x10iW\x80`\x1F\x10a\x10@Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x10iV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x10LW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x15\x03\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x10\x87\x87\x84a\x1BBV[\x81Q\x81\x10a\x10\x97Wa\x10\x97a\x1BUV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x0F\xAEV[P\x94\x93PPPPV[``a\x10\xBF\x84\x84a\x1BBV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10\xD7Wa\x10\xD7a\x16\x89V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x11\0W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x10\xAAWa\x11\xD3\x86a\x11\x1A\x83a\x13\xD2V[\x85`@Q` \x01a\x11-\x93\x92\x91\x90a\x1C\x15V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x11I\x90a\x1B\xADV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x11u\x90a\x1B\xADV[\x80\x15a\x11\xC0W\x80`\x1F\x10a\x11\x97Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x11\xC0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x11\xA3W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x15\xA2\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x11\xDE\x87\x84a\x1BBV[\x81Q\x81\x10a\x11\xEEWa\x11\xEEa\x1BUV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x11\x05V[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x12jW__\xFD[PZ\xFA\x15\x80\x15a\x12|W=__>=_\xFD[PPPPPPV[``a\x12\x90\x84\x84a\x1BBV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\xA8Wa\x12\xA8a\x16\x89V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x12\xD1W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x10\xAAWa\x13\xA4\x86a\x12\xEB\x83a\x13\xD2V[\x85`@Q` \x01a\x12\xFE\x93\x92\x91\x90a\x1C\x15V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x13\x1A\x90a\x1B\xADV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x13F\x90a\x1B\xADV[\x80\x15a\x13\x91W\x80`\x1F\x10a\x13hWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x13\x91V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x13tW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x165\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x13\xAF\x87\x84a\x1BBV[\x81Q\x81\x10a\x13\xBFWa\x13\xBFa\x1BUV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x12\xD6V[``\x81_\x03a\x14\x14WPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x14=W\x80a\x14'\x81a\x1C\xB2V[\x91Pa\x146\x90P`\n\x83a\x1D\x16V[\x91Pa\x14\x17V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x14WWa\x14Wa\x16\x89V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x14\x81W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x02\xBAWa\x14\x96`\x01\x83a\x1BBV[\x91Pa\x14\xA3`\n\x86a\x1D)V[a\x14\xAE\x90`0a\x1D=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x15\x99\x91\x90\x81\x01\x90a\x1D|V[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x15\xF6\x90\x86\x90\x86\x90`\x04\x01a\x1DOV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x16\x11W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x15\x99\x91\x90a\x1B\xFEV[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x15\xF6\x90\x86\x90\x86\x90`\x04\x01a\x1DOV[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x16\xDFWa\x16\xDFa\x16\x89V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x17\0Wa\x17\0a\x16\x89V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x17 W__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x176W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x17FW__\xFD[\x805a\x17Ya\x17T\x82a\x16\xE7V[a\x16\xB6V[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x17mW__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x18\x1AW`?\x19\x87\x86\x03\x01\x84Ra\x18\x05\x85\x83Qa\x17\x95V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x17\xE9V[P\x92\x96\x95PPPPPPV[` \x81R_a\x15\x99` \x83\x01\x84a\x17\x95V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x18\x85W\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\x18QV[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x18\xDEW`\x1F\x19\x85\x84\x03\x01\x88Ra\x18\xC8\x83\x83Qa\x17\x95V[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x18\xACV[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x18\x1AW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x19X`@\x87\x01\x82a\x18\x90V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x19\x10V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x18\x85W\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x19\x87V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x19\xF7W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x19\xB7V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x18\x1AW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x1AM`@\x88\x01\x82a\x17\x95V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x1Ah\x81\x83a\x19\xA5V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1A'V[` \x81R_a\x15\x99` \x83\x01\x84a\x18\x90V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x18\x1AW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1A\xFF`@\x87\x01\x82a\x19\xA5V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1A\xB7V[\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\x15\x9CWa\x15\x9Ca\x1B\x15V[\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x02\xBAa\x1B\xA7\x83\x86a\x1B\x82V[\x84a\x1B\x82V[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1B\xC1W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x1B\xF8W\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x1C\x0EW__\xFD[PQ\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\x81R_a\x1CF`\x01\x83\x01\x86a\x1B\x82V[\x7F[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x1Cv`\x01\x82\x01\x86a\x1B\x82V[\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\x81Ra\x1C\xA8`\x02\x82\x01\x85a\x1B\x82V[\x96\x95PPPPPPV[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x1C\xE2Wa\x1C\xE2a\x1B\x15V[P`\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`\x12`\x04R`$_\xFD[_\x82a\x1D$Wa\x1D$a\x1C\xE9V[P\x04\x90V[_\x82a\x1D7Wa\x1D7a\x1C\xE9V[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a\x15\x9CWa\x15\x9Ca\x1B\x15V[`@\x81R_a\x1Da`@\x83\x01\x85a\x17\x95V[\x82\x81\x03` \x84\x01Ra\x1Ds\x81\x85a\x17\x95V[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x1D\x8CW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xA2W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x1D\xB2W__\xFD[\x80Qa\x1D\xC0a\x17T\x82a\x16\xE7V[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a\x1D\xD4W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV\xFE\xA2dipfsX\"\x12 \xAE\xE7\xFEBH,\xB5\x88V:\xB8\xDC\x8C\x14\x82\xDF\xBA2\xF7\t\xFB9c\x87\x1D\x10\xDFX\x010\xB1\xFCdsolcC\0\x08\x1C\x003`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa);8\x03\x80a);\x839\x81\x01`@\x81\x90Ra\0.\x91a\x03+V[\x82\x82\x82\x82\x82\x82a\0?\x83Q`P\x14\x90V[a\0\x84W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x11`$\x82\x01RpBad genesis block`x\x1B`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\0\x8E\x84a\x01fV[\x90Pb\xFF\xFF\xFF\x82\x16\x15a\x01\tW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FPeriod start hash does not have `D\x82\x01R\x7Fwork. Hint: wrong byte order?\0\0\0`d\x82\x01R`\x84\x01a\0{V[_\x81\x81U`\x01\x82\x90U`\x02\x82\x90U\x81\x81R`\x04` R`@\x90 \x83\x90Ua\x012a\x07\xE0\x84a\x03\xFEV[a\x01<\x90\x84a\x04%V[_\x83\x81R`\x04` R`@\x90 Ua\x01S\x84a\x02&V[`\x05UPa\x05\xBD\x98PPPPPPPPPV[_`\x02\x80\x83`@Qa\x01x\x91\x90a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\x93W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x04NV[`@Q` \x01a\x01\xC8\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x01\xE2\x91a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\xFDW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02 \x91\x90a\x04NV[\x92\x91PPV[_a\x02 a\x023\x83a\x028V[a\x02CV[_a\x02 \x82\x82a\x02SV[_a\x02 a\xFF\xFF`\xD0\x1B\x83a\x02\xF7V[_\x80a\x02ja\x02c\x84`Ha\x04eV[\x85\x90a\x03\tV[`\xE8\x1C\x90P_\x84a\x02|\x85`Ka\x04eV[\x81Q\x81\x10a\x02\x8CWa\x02\x8Ca\x04xV[\x01` \x01Q`\xF8\x1C\x90P_a\x02\xBE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x02\xD1`\x03\x84a\x04\x8CV[`\xFF\x16\x90Pa\x02\xE2\x81a\x01\0a\x05\x88V[a\x02\xEC\x90\x83a\x05\x93V[\x97\x96PPPPPPPV[_a\x03\x02\x82\x84a\x05\xAAV[\x93\x92PPPV[_a\x03\x02\x83\x83\x01` \x01Q\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x03=W__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03RW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03bW__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03{Wa\x03{a\x03\x17V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x03\xA9Wa\x03\xA9a\x03\x17V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x03\xC0W__\xFD[\x81` \x84\x01` \x83\x01^_` \x92\x82\x01\x83\x01R\x90\x86\x01Q`@\x90\x96\x01Q\x90\x97\x95\x96P\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x04\x0CWa\x04\x0Ca\x03\xEAV[P\x06\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x04^W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02 Wa\x02 a\x04\x11V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[`\x01\x81[`\x01\x84\x11\x15a\x04\xE0W\x80\x85\x04\x81\x11\x15a\x04\xC4Wa\x04\xC4a\x04\x11V[`\x01\x84\x16\x15a\x04\xD2W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x04\xA9V[\x93P\x93\x91PPV[_\x82a\x04\xF6WP`\x01a\x02 V[\x81a\x05\x02WP_a\x02 V[\x81`\x01\x81\x14a\x05\x18W`\x02\x81\x14a\x05\"Wa\x05>V[`\x01\x91PPa\x02 V[`\xFF\x84\x11\x15a\x053Wa\x053a\x04\x11V[PP`\x01\x82\x1Ba\x02 V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x05aWP\x81\x81\na\x02 V[a\x05m_\x19\x84\x84a\x04\xA5V[\x80_\x19\x04\x82\x11\x15a\x05\x80Wa\x05\x80a\x04\x11V[\x02\x93\x92PPPV[_a\x03\x02\x83\x83a\x04\xE8V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x02 Wa\x02 a\x04\x11V[_\x82a\x05\xB8Wa\x05\xB8a\x03\xEAV[P\x04\x90V[a#q\x80a\x05\xCA_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\xADW\x80c\xB9\x85b\x1A\x11a\0}W\x80c\xE3\xD8\xD8\xD8\x11a\0cW\x80c\xE3\xD8\xD8\xD8\x14a\x02\"W\x80c\xE4q\xE7,\x14a\x02)W\x80c\xF5\x8D\xB0o\x14a\x02=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x13\x91\x90a!WV[`@Q` \x01a\x0C%\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\x90\x82\x90Ra\x0C]\x91a!AV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0CxW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x07\x91\x90a!WV[_\x83\x85\x14\x80\x15a\x0C\xAAWP\x82\x85\x14[\x15a\x0C\xB7WP`\x01a\x04\xF1V[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x0C\xFFW\x89\x83\x14a\x0C\xDEW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x0C\xF7W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x0C\xBDV[P\x82\x84\x03a\r\x13W_\x94PPPPPa\x04\xF1V[\x80\x82\x14a\r&W_\x94PPPPPa\x04\xF1V[P`\x01\x98\x97PPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\rYW_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\r9V[P\x80a\x05\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x80\x82\x81[a\r\xB8`\x04`\x01a!\x9BV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0E\x0CW_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\r\xF1W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0E\x04V[a\r\xFB\x81\x84a!\xB7V[\x95\x94PPPPPV[`\x01\x01a\r\xACV[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_`P\x82Qa\x0B~\x91\x90a!.V[__a\x0Eo\x85a\x0B\xC3V[\x90P_a\x0E{\x82a\r\xA7V[\x90P_a\x0E\x87\x86a\x19\xE6V[\x90P\x84\x80a\x0E\x9CWP\x80a\x0E\x9A\x88a\x19\xE6V[\x14[a\x0F\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x03.V[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x12\x0EWa\x0F(`P\x82a!\xCAV[a\x0F3\x90`\x01a!\xB7V[a\x0F=\x90\x87a!\xB7V[\x93Pa\x0FK\x8A\x82`Pa\x19\xF1V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x11!W\x84a\x10\xA1\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x10\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x11\n`\x04\x85a!.V[_\x03a\x11!W_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x11,\x8B\x83a\x1A\x16V[\x14a\x11yW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[\x86a\x11\x84\x8B\x83a\x1A\xAFV[\x14a\x11\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x03.V[\x82\x96P`P\x81a\x12\x07\x91\x90a!\xB7V[\x90Pa\x0F\x15V[P\x81a\x12\x19\x8Ba\x0B\xC3V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x12\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x12\xD4\x84a\x0B\xC3V[\x90P_a\x12\xE0\x86a\x0B\xC3V[\x90P`\x01T\x81\x14a\x133W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x03.V[_\x82\x81R`\x03` R`@\x90 Ta\x13\x8DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x13\x9B\x87`\x01T\x84\x87a\x0C\x9BV[a\x14\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x03.V[\x81a\x14\x19\x88\x88\x88a\x17\x80V[\x14a\x14\x8CW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[`\x01\x82\x90U`\x02\x87\x90U_a\x14\xA0\x86a\x1A\xC7V[\x90P`\x05T\x81\x14a\x14\xB1W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x15\x01a\x14\xFC\x86a\x0B\xC3V[a\r\xA7V[\x90P_a\x15\x10a\x14\xFC\x86a\x0B\xC3V[\x90Pa\x15\x1Ea\x07\xE0\x82a!.V[a\x07\xDF\x14a\x15\x94W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x03.V[a\x15\xA0\x82a\x07\xDFa!\xB7V[\x81\x14a\x16\x14W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x03.V[a\x16\x1D\x85a\x1A\xC7V[a\x16&\x87a\x1A\xC7V[\x14a\x16\x99W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x03.V[_a\x16\xA3\x85a\x19\xE6V[\x90P_a\x16\xD5a\x16\xB2\x89a\x19\xE6V[a\x16\xBB\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x16\xCA\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x1B\x0CV[\x90P\x81\x81\x83\x16\x14a\x17(W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_a\x172\x89a\x1A\xC7V[\x90P\x80`\x06T\x14\x15\x80\x15a\x17\\WPa\x07\xE0a\x17O`\x01Ta\r\xA7V[a\x17Y\x91\x90a!\xDDV[\x84\x11[\x15a\x17gW`\x06\x81\x90U[a\x17s\x88\x88`\x01a\x0EdV[\x99\x98PPPPPPPPPV[__a\x17\x8B\x85a\r\xA7V[\x90P_a\x17\x9Aa\x14\xFC\x86a\x0B\xC3V[\x90P_a\x17\xA9a\x14\xFC\x86a\x0B\xC3V[\x90P\x82\x82\x10\x15\x80\x15a\x17\xBBWP\x82\x81\x10\x15[a\x18-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x18:a\x07\xE0\x85a!.V[a\x18F\x85a\x07\xE0a!\xB7V[a\x18P\x91\x90a!\xDDV[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x18bWP\x80[\x15a\x18}Wa\x18p\x89a\x0B\xC3V[\x96PPPPPPPa\n\xA3V[\x81\x80\x15a\x18\x88WP\x80\x15[\x15a\x18\x96Wa\x18p\x88a\x0B\xC3V[\x81\x80\x15a\x18\xA0WP\x80[\x15a\x18\xC4W\x83\x85\x10\x15a\x18\xBBWa\x18\xB6\x88a\x0B\xC3V[a\x18pV[a\x18p\x89a\x0B\xC3V[a\x18\xCD\x88a\x1A\xC7V[a\x18\xD9a\x07\xE0\x86a!.V[a\x18\xE3\x91\x90a!\xF0V[a\x18\xEC\x8Aa\x1A\xC7V[a\x18\xF8a\x07\xE0\x88a!.V[a\x19\x02\x91\x90a!\xF0V[\x10\x15a\x18\xBBWa\x18p\x88a\x0B\xC3V[`\x07T_\x90`\xFF\x16\x15a\x19/WP`\x07Ta\x01\0\x90\x04`\xFF\x16a\n\xA3V[a\x19:\x84\x84\x84a\x1B\x94V[\x90Pa\n\xA3V[_` \x84Qa\x19P\x91\x90a!.V[\x15a\x19\\WP_a\x04\xF1V[\x83Q_\x03a\x19kWP_a\x04\xF1V[\x81\x85_[\x86Q\x81\x10\x15a\x19\xD9Wa\x19\x83`\x02\x84a!.V[`\x01\x03a\x19\xA7Wa\x19\xA0a\x19\x9A\x88\x83\x01` \x01Q\x90V[\x83a\x1B\xD5V[\x91Pa\x19\xC0V[a\x19\xBD\x82a\x19\xB8\x89\x84\x01` \x01Q\x90V[a\x1B\xD5V[\x91P[`\x01\x92\x90\x92\x1C\x91a\x19\xD2` \x82a!\xB7V[\x90Pa\x19oV[P\x90\x93\x14\x95\x94PPPPPV[_a\x05\x07\x82_a\x1A\x16V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x1A-a\x1A&\x84`Ha!\xB7V[\x85\x90a\x1B\xE0V[`\xE8\x1C\x90P_\x84a\x1A?\x85`Ka!\xB7V[\x81Q\x81\x10a\x1AOWa\x1AOa\"\x07V[\x01` \x01Q`\xF8\x1C\x90P_a\x1A\x81\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1A\x94`\x03\x84a\"4V[`\xFF\x16\x90Pa\x1A\xA5\x81a\x01\0a#0V[a\x08-\x90\x83a!\xF0V[_a\x05\x04a\x1A\xBE\x83`\x04a!\xB7V[\x84\x01` \x01Q\x90V[_a\x05\x07a\x1A\xD4\x83a\x19\xE6V[a\x1B\xEEV[_a\x05\x07a\x1A\xE6\x83a\x1C\x15V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1B\x18\x83\x85a\x1C!V[\x90Pa\x1B(b\x12u\0`\x04a\x1C|V[\x81\x10\x15a\x1B@Wa\x1B=b\x12u\0`\x04a\x1C|V[\x90P[a\x1BNb\x12u\0`\x04a\x1C\x87V[\x81\x11\x15a\x1BfWa\x1Bcb\x12u\0`\x04a\x1C\x87V[\x90P[_a\x1B~\x82a\x1Bx\x88b\x01\0\0a\x1C|V[\x90a\x1C\x87V[\x90Pa\n\x8Ab\x01\0\0a\x1Bx\x83b\x12u\0a\x1C|V[_\x82\x81[\x83\x81\x10\x15a\x1B\xCAW\x85\x82\x03a\x1B\xB2W`\x01\x92PPPa\n\xA3V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x1B\x98V[P_\x95\x94PPPPPV[_a\x05\x04\x83\x83a\x1C\xFAV[_a\x05\x04\x83\x83\x01` \x01Q\x90V[_a\x05\x07{\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\x83a\x1C|V[_a\x05\x07\x82`Da\x1B\xE0V[_\x82\x82\x11\x15a\x1CrW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x05\x04\x82\x84a!\xDDV[_a\x05\x04\x82\x84a!\xCAV[_\x82_\x03a\x1C\x96WP_a\x05\x07V[a\x1C\xA0\x82\x84a!\xF0V[\x90P\x81a\x1C\xAD\x84\x83a!\xCAV[\x14a\x05\x07W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x03.V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1D1W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DHW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1D_W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1DvW__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1D\x91W__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xA7W__\xFD[a\x1D\xB3\x8A\x82\x8B\x01a\x1D!V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xD2W__\xFD[a\x1D\xDE\x8A\x82\x8B\x01a\x1D!V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1D\xFE`\x80\x89\x01a\x1DfV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[____`\x80\x85\x87\x03\x12\x15a\x1E\x1FW__\xFD[PP\x825\x94` \x84\x015\x94P`@\x84\x015\x93``\x015\x92P\x90PV[__`@\x83\x85\x03\x12\x15a\x1ELW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1EkW__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1E\x85W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x9BW__\xFD[a\x1E\xA7\x87\x82\x88\x01a\x1D!V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\xC6W__\xFD[a\x1E\xD2\x87\x82\x88\x01a\x1D!V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1E\xF3W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x10W__\xFD[a\x1F\x1C\x89\x82\x8A\x01a\x1D!V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F;W__\xFD[a\x1FG\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1FtW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x8AW__\xFD[a\x1F\x96\x89\x82\x8A\x01a\x1D!V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xB5W__\xFD[a\x1F\xC1\x89\x82\x8A\x01a\x1D!V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xE0W__\xFD[a\x1F\xEC\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_____``\x86\x88\x03\x12\x15a \x12W__\xFD[\x855\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a /W__\xFD[a ;\x88\x82\x89\x01a\x1D!V[\x90\x95P\x93PP`@\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a ZW__\xFD[a f\x88\x82\x89\x01a\x1D!V[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[___``\x84\x86\x03\x12\x15a \x89W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a \xB1W__\xFD[\x825\x91Pa \xC1` \x84\x01a\x1DfV[\x90P\x92P\x92\x90PV[\x805\x80\x15\x15\x81\x14a\x1DvW__\xFD[__`@\x83\x85\x03\x12\x15a \xEAW__\xFD[a \xF3\x83a \xCAV[\x91Pa \xC1` \x84\x01a \xCAV[\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!^<#\x11a\0\xCEW\x80c>^<#\x14a\x01DW\x80c?r\x86\xF4\x14a\x01LW\x80cf\xD9\xA9\xA0\x14a\x01TW\x80c\x85\"l\x81\x14a\x01iW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x15\xBC\xF6[\x14a\x01\tW\x80c\x1E\xD7\x83\x1C\x14a\x01\x11W\x80c*\xDE8\x80\x14a\x01/W[__\xFD[a\x01\x07a\x02-V[\0[a\x01\x07a\x02jV[a\x01\x19a\x07)V[`@Qa\x01&\x91\x90a\x12\xFEV[`@Q\x80\x91\x03\x90\xF3[a\x017a\x07\x96V[`@Qa\x01&\x91\x90a\x13\x84V[a\x01\x19a\x08\xDFV[a\x01\x19a\tJV[a\x01\\a\t\xB5V[`@Qa\x01&\x91\x90a\x14\xD4V[a\x01qa\x0B.V[`@Qa\x01&\x91\x90a\x15RV[a\x01\x86a\x0B\xF9V[`@Qa\x01&\x91\x90a\x15\xA9V[a\x01\x86a\x0C\xFCV[a\x01qa\r\xFFV[a\x01\xABa\x0E\xCAV[`@Q\x90\x15\x15\x81R` \x01a\x01&V[a\x01\x19a\x0F\x9AV[a\x01\x07a\x01\xD16`\x04a\x16UV[a\x10\x05V[`\x1FTa\x01\xAB\x90`\xFF\x16\x81V[`\x1FTa\x02\x08\x90a\x01\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[`@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&V[a\x02hbeY\xC7sZ\x8E\x97t\xD6\x7F\xE8F\xC6\xF41\x1C\x07>*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x10\x05V[V[_sT\x1F\xD7IA\x9C\xA8\x06\xA8\xBC}\xA8\xAC#\xD3F\xF2\xDF\x8Bw\x90P_s\xCC\tf\xD8A\x8DA,Y\x9Ad!\xB7`\xA8G\xEB\x16\x9A\x8C\x90P_sI\xB0r\x15\x85d\xDB60E\x18\xFF\xA3{\x1C\xFC\x13\x91j\x90s\xBAF\xFC\xC1kFM\x97\x871Ag\xBD\xD9\xF1\xCE(@[\xA1\x7FVdR\x02@\xA4kK>\x96U\xC2\x0C\xC3\xF9\xE0\x84\x96\xA9\xB7F\xA4x\xE4v\xAE>\x04\xD6\xC8\xFC1\x7Fh\x99\xA7\xE1;e_\xA3g \x8C\xB2|n\xAA$\x107\r\x15e\xDC\x1F_\x11\x85:\x1E\x8C\xBE\xF03\x86\x86`@Qa\x03\x15\x90a\x12\xD7V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x96\x87\x16\x81R\x94\x86\x16` \x86\x01R`@\x85\x01\x93\x90\x93R``\x84\x01\x91\x90\x91R\x83\x16`\x80\x83\x01R\x90\x91\x16`\xA0\x82\x01R`\xC0\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03rW=__>=_\xFD[P\x90P_r\xB6~H\x05\x13\x83%\xCE\x87\x1D^'\xDC\x15\xF9\x94h\x1B\xC1so\n\xFA\xDE\x16\xBF\xD2\xE7\xF5QV4\xF2\xD0\xE3\xCD\x03\xC8E\xEF`@Qa\x03\xAB\x90a\x12\xE4V[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03\xE8W=__>=_\xFD[P\x90P_\x82\x82`@Qa\x03\xFA\x90a\x12\xF1V[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x047W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xB1W__\xFD[PZ\xF1\x15\x80\x15a\x04\xC3W=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x05FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05j\x91\x90a\x16\x96V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05\xFEW__\xFD[PZ\xF1\x15\x80\x15a\x06\x10W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x06mW__\xFD[PZ\xF1\x15\x80\x15a\x06\x7FW=__>=_\xFD[PP`@Q\x7Ft\xD1E\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\x81R`\x01`\x04\x82\x01Ra\x07\"\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x91Pct\xD1E\xB7\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xF0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x14\x91\x90a\x16\xBCV[g\r\xE0\xB6\xB3\xA7d\0\0a\x12TV[PPPPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07\x8CW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x07aW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x08\xBFW\x83\x82\x90_R` _ \x01\x80Ta\x084\x90a\x16\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x08`\x90a\x16\xD3V[\x80\x15a\x08\xABW\x80`\x1F\x10a\x08\x82Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x08\xABV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x08\x8EW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x08\x17V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07\xB9V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07\x8CW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x07aWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07\x8CW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x07aWPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\n\x08\x90a\x16\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n4\x90a\x16\xD3V[\x80\x15a\n\x7FW\x80`\x1F\x10a\nVWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\x7FV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\nbW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x0B\x16W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\n\xC3W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\t\xD8V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W\x83\x82\x90_R` _ \x01\x80Ta\x0Bn\x90a\x16\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\x9A\x90a\x16\xD3V[\x80\x15a\x0B\xE5W\x80`\x1F\x10a\x0B\xBCWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\xE5V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xC8W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0BQV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\xE4W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C\x91W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0C\x1CV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\xE7W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\x94W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\r\x1FV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W\x83\x82\x90_R` _ \x01\x80Ta\x0E?\x90a\x16\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0Ek\x90a\x16\xD3V[\x80\x15a\x0E\xB6W\x80`\x1F\x10a\x0E\x8DWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0E\xB6V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0E\x99W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0E\"V[`\x08T_\x90`\xFF\x16\x15a\x0E\xE1WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0FoW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\x93\x91\x90a\x16\xBCV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07\x8CW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x07aWPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\xA0W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x10\xC7\x91\x90\x81\x01\x90a\x17QV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x10\xE5\x92\x91\x90a\x18\x05V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11\x01W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11%\x91\x90a\x16\xBCV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x11\x9EW__\xFD[PZ\xF1\x15\x80\x15a\x11\xB0W=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x120W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\"\x91\x90a\x16\x96V[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x12\xBDW__\xFD[PZ\xFA\x15\x80\x15a\x12\xCFW=__>=_\xFD[PPPPPPV[a\x0F-\x80a\x18'\x839\x01\x90V[a\x0C\xF5\x80a'T\x839\x01\x90V[a\r \x80a4I\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x13KW\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\x13\x17V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14lW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x14RW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x14<\x84\x86Qa\x13VV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x14\x02V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x13\xAAV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x14\xCAW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x14\x8AV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14lW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x15 `@\x88\x01\x82a\x13VV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x15;\x81\x83a\x14xV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\xFAV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14lW`?\x19\x87\x86\x03\x01\x84Ra\x15\x94\x85\x83Qa\x13VV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15xV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14lW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x16\x17`@\x87\x01\x82a\x14xV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\xCFV[\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\x16PW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x16hW__\xFD[\x845\x93Pa\x16x` \x86\x01a\x16-V[\x92Pa\x16\x86`@\x86\x01a\x16-V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[_` \x82\x84\x03\x12\x15a\x16\xA6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x16\xB5W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x16\xCCW__\xFD[PQ\x91\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x16\xE7W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x17\x1EW\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[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\x17aW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17wW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x17\x87W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17\xA1Wa\x17\xA1a\x17$V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x17\xD1Wa\x17\xD1a\x17$V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x17\xE8W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x18\x17`@\x83\x01\x85a\x13VV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFEa\x01@`@R4\x80\x15a\0\x10W__\xFD[P`@Qa\x0F-8\x03\x80a\x0F-\x839\x81\x01`@\x81\x90Ra\0/\x91a\0sV[`\x01`\x01`\xA0\x1B\x03\x95\x86\x16`\x80R\x93\x85\x16`\xA0R`\xC0\x92\x90\x92R`\xE0R\x82\x16a\x01\0R\x16a\x01 Ra\0\xE3V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0pW__\xFD[PV[______`\xC0\x87\x89\x03\x12\x15a\0\x88W__\xFD[\x86Qa\0\x93\x81a\0\\V[` \x88\x01Q\x90\x96Pa\0\xA4\x81a\0\\V[`@\x88\x01Q``\x89\x01Q`\x80\x8A\x01Q\x92\x97P\x90\x95P\x93Pa\0\xC4\x81a\0\\V[`\xA0\x88\x01Q\x90\x92Pa\0\xD5\x81a\0\\V[\x80\x91PP\x92\x95P\x92\x95P\x92\x95V[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\r\xC6a\x01g_9_\x81\x81a\x01.\x01R\x81\x81a\x04\xFC\x01Ra\x05>\x01R_\x81\x81a\x01U\x01Ra\x03R\x01R_\x81\x81a\x01\xB1\x01Ra\x03\xC1\x01R_\x81\x81a\x01|\x01Ra\x02\x88\x01R_\x81\x81`\xDF\x01R\x81\x81a\x03t\x01Ra\x03\xF0\x01R_\x81\x81`\x8E\x01R\x81\x81a\x02;\x01Ra\x02\xB7\x01Ra\r\xC6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\x85W_5`\xE0\x1C\x80c\xADt}\xE6\x11a\0XW\x80c\xADt}\xE6\x14a\x01)W\x80c\xB9\x93|\xCB\x14a\x01PW\x80c\xC8\xC7\xF7\x01\x14a\x01wW\x80c\xE3L\xEF\x86\x14a\x01\xACW__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0\x89W\x80cN=\xF3\xF4\x14a\0\xDAW\x80cPcL\x0E\x14a\x01\x01W\x80c\x7F\x81O5\x14a\x01\x16W[__\xFD[a\0\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\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\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\x81V[a\x01\x14a\x01\x0F6`\x04a\x0BgV[a\x01\xD3V[\0[a\x01\x14a\x01$6`\x04a\x0C)V[a\x01\xFDV[a\0\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\x81V[a\0\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\x81V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xD1V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\xE8\x91\x90a\x0C\xADV[\x90Pa\x01\xF6\x85\x85\x85\x84a\x01\xFDV[PPPPPV[a\x02\x1Fs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x9AV[a\x02`s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x036\x91\x90a\x0C\xD1V[\x90Pa\x03\x99s\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\x7F\0\0\0\0\0\0\0\0\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\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x82\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04KW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04o\x91\x90a\x0C\xD1V[\x83Q\x90\x91P\x81\x10\x15a\x04\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[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\x85\x83a\x07YV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x06X\x90\x85\x90\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\x90`\x84\x01[`@\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\x07\xB4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF6\x91\x90a\x0C\xD1V[a\x07\0\x91\x90a\x0C\xE8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x06X\x90\x85\x90\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\x90`d\x01a\x05\xF4V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07\xAF\x90\x84\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\x90`d\x01a\x05\xF4V[PPPV[_a\x08\x15\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\x08\xBF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\xAFW\x80\x80` \x01\x90Q\x81\x01\x90a\x083\x91\x90a\r&V[a\x07\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\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\x04\xD9V[``a\x08\xCD\x84\x84_\x85a\x08\xD7V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\tiW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x04\xD9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\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`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x04\xD9V[__\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\n\x0F\x91\x90a\rEV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\nIW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\nNV[``\x91P[P\x91P\x91Pa\n^\x82\x82\x86a\niV[\x97\x96PPPPPPPV[``\x83\x15a\nxWP\x81a\x08\xD0V[\x82Q\x15a\n\x88W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x04\xD9\x91\x90a\r[V[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\xDDW__\xFD[PV[\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\x0B0Wa\x0B0a\n\xE0V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0B_Wa\x0B_a\n\xE0V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0BzW__\xFD[\x845a\x0B\x85\x81a\n\xBCV[\x93P` \x85\x015\x92P`@\x85\x015a\x0B\x9C\x81a\n\xBCV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xB7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\x0B\xC7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xE1Wa\x0B\xE1a\n\xE0V[a\x0B\xF4` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0B6V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0C\x08W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0C=W__\xFD[\x855a\x0CH\x81a\n\xBCV[\x94P` \x86\x015\x93P`@\x86\x015a\x0C_\x81a\n\xBCV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0C\x90W__\xFD[Pa\x0C\x99a\x0B\rV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0C\xBEW__\xFD[Pa\x0C\xC7a\x0B\rV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C\xE1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\r 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[_` \x82\x84\x03\x12\x15a\r6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x08\xD0W__\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\xFE\xA2dipfsX\"\x12 \xD28\x8C\xB3\xDCz\xA6\xF5\xA2\xEBuA}\x11\x05\x9B\xE1<\x8C\x9E\xAB\xE5\xD7\xEA\xDB\x1BV\x1F\x93\x7F\xF6\x91dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x0C\xF58\x03\x80a\x0C\xF5\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\x1Ea\0\xD7_9_\x81\x81`\xBB\x01R\x81\x81a\x01\x98\x01Ra\x02\xDB\x01R_\x81\x81a\x01\x07\x01R\x81\x81a\x01\xC2\x01R\x81\x81a\x02q\x01Ra\x03\x14\x01Ra\x0C\x1E_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0dW_5`\xE0\x1C\x80c\x7F\x81O5\x11a\0MW\x80c\x7F\x81O5\x14a\0\xA3W\x80c\xA6\xAA\x9C\xC0\x14a\0\xB6W\x80c\xC9F\x1AD\x14a\x01\x02W__\xFD[\x80cPcL\x0E\x14a\0hW\x80ct\xD1E\xB7\x14a\0}W[__\xFD[a\0{a\0v6`\x04a\t\xAAV[a\x01)V[\0[a\0\x90a\0\x8B6`\x04a\nlV[a\x01SV[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0{a\0\xB16`\x04a\n\x87V[a\x023V[a\0\xDD\x7F\0\0\0\0\0\0\0\0\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\0\x9AV[a\0\xDD\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01>\x91\x90a\x0B\x0BV[\x90Pa\x01L\x85\x85\x85\x84a\x023V[PPPPPV[`@Q\x7Fz~\r\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\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\x7F\0\0\0\0\0\0\0\0\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`$\x83\x01R_\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\x90\x91\x16\x90cz~\r\x92\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\tW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02-\x91\x90a\x0B/V[\x92\x91PPV[a\x02Us\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x043V[a\x02\x96s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\xF7V[`@Q\x7F\xE4hB\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\x83\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\x81\x16`$\x83\x01R\x85\x81\x16`D\x83\x01R`d\x82\x01\x85\x90R_\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\x90\x91\x16\x90c\xE4hB\xB7\x90`\x84\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\\W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x80\x91\x90a\x0B/V[\x82Q\x90\x91P\x81\x10\x15a\x03\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q_\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xF1\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xF2V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05kW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x8F\x91\x90a\x0B/V[a\x05\x99\x91\x90a\x0BFV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xF1\x90\x85\x90\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\x90`d\x01a\x04\x8DV[_a\x06S\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\x07\x02\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\xFDW\x80\x80` \x01\x90Q\x81\x01\x90a\x06q\x91\x90a\x0B~V[a\x06\xFDW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[PPPV[``a\x07\x10\x84\x84_\x85a\x07\x1AV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xACW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08*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\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x03\xEAV[__\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\x08R\x91\x90a\x0B\x9DV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x8CW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x91V[``\x91P[P\x91P\x91Pa\x08\xA1\x82\x82\x86a\x08\xACV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xBBWP\x81a\x07\x13V[\x82Q\x15a\x08\xCBW\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\xEA\x91\x90a\x0B\xB3V[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\t W__\xFD[PV[\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\tsWa\tsa\t#V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xA2Wa\t\xA2a\t#V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xBDW__\xFD[\x845a\t\xC8\x81a\x08\xFFV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xDF\x81a\x08\xFFV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xFAW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\nW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n$Wa\n$a\t#V[a\n7` `\x1F\x19`\x1F\x84\x01\x16\x01a\tyV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nKW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[_` \x82\x84\x03\x12\x15a\n|W__\xFD[\x815a\x07\x13\x81a\x08\xFFV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x9BW__\xFD[\x855a\n\xA6\x81a\x08\xFFV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xBD\x81a\x08\xFFV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xEEW__\xFD[Pa\n\xF7a\tPV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x1CW__\xFD[Pa\x0B%a\tPV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B?W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02-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[_` \x82\x84\x03\x12\x15a\x0B\x8EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x13W__\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\xFE\xA2dipfsX\"\x12 1\xA9_\tS$\x80\xC4eD\\\xF1\xA5F\x84\x08w?\xBD\x88\xEC\xC5\xCAl\x9C\xCA\x82\xDE\xCAb4\x08dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r 8\x03\x80a\r \x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CJa\0\xD6_9_\x81\x81`{\x01R\x81\x81a\x03u\x01Ra\x03\xF5\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0CJ_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cPcL\x0E\x14a\0NW\x80c\x7F\x81O5\x14a\0cW\x80c\xA6\xAA\x9C\xC0\x14a\0vW\x80c\xF2#L\xF9\x14a\0\xC6W[__\xFD[a\0aa\0\\6`\x04a\t\xD0V[a\0\xEDV[\0[a\0aa\0q6`\x04a\n\x92V[a\x01\x17V[a\0\x9D\x7F\0\0\0\0\0\0\0\0\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\x9D\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 ;\xBE\xA4\0\nXD\x11.v'\xBB\xE5\xECgi\x01\x98\xF0\xDF\xD9,\xA6^&\r\xB6\x93\x85\x0Bf\xA8dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 (\x9F\xC0L\xB8\xC0\x0E\x14\xCF\xB1\x04\xF5\xC8F\xD3\x8C\xA3\x05\x19Y:K\x02\xB7\xCF\xD6~\x1B\xA9\x96\xC7JdsolcC\0\x08\x1C\x003", ); /// 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\x01/W_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\xADW\x80c\xC7.\xD5\xEB\x11a\0}W\x80c\xF4\xB0\xEF\xF0\x11a\0cW\x80c\xF4\xB0\xEF\xF0\x14a\x02OW\x80c\xFAv&\xD4\x14a\x02WW\x80c\xFA\xD0k\x8F\x14a\x02dW__\xFD[\x80c\xC7.\xD5\xEB\x14a\x02=W\x80c\xE2\x0C\x9Fq\x14a\x02GW__\xFD[\x80c\x91j\x17\xC6\x14a\x02\0W\x80c\xB0FO\xDC\x14a\x02\x15W\x80c\xB5P\x8A\xA9\x14a\x02\x1DW\x80c\xBAAO\xA6\x14a\x02%W__\xFD[\x80c>^<#\x11a\x01\x02W\x80cD\xBA\xDB\xB6\x11a\0\xE8W\x80cD\xBA\xDB\xB6\x14a\x01\xB6W\x80cf\xD9\xA9\xA0\x14a\x01\xD6W\x80c\x85\"l\x81\x14a\x01\xEBW__\xFD[\x80c>^<#\x14a\x01\xA6W\x80c?r\x86\xF4\x14a\x01\xAEW__\xFD[\x80c\x08\x13\x85*\x14a\x013W\x80c\x1C\r\xA8\x1F\x14a\x01\\W\x80c\x1E\xD7\x83\x1C\x14a\x01|W\x80c*\xDE8\x80\x14a\x01\x91W[__\xFD[a\x01Fa\x01A6`\x04a\x17\x0EV[a\x02wV[`@Qa\x01S\x91\x90a\x17\xC3V[`@Q\x80\x91\x03\x90\xF3[a\x01oa\x01j6`\x04a\x17\x0EV[a\x02\xC2V[`@Qa\x01S\x91\x90a\x18&V[a\x01\x84a\x034V[`@Qa\x01S\x91\x90a\x188V[a\x01\x99a\x03\xA1V[`@Qa\x01S\x91\x90a\x18\xEAV[a\x01\x84a\x04\xEAV[a\x01\x84a\x05UV[a\x01\xC9a\x01\xC46`\x04a\x17\x0EV[a\x05\xC0V[`@Qa\x01S\x91\x90a\x19nV[a\x01\xDEa\x06\x03V[`@Qa\x01S\x91\x90a\x1A\x01V[a\x01\xF3a\x07|V[`@Qa\x01S\x91\x90a\x1A\x7FV[a\x02\x08a\x08GV[`@Qa\x01S\x91\x90a\x1A\x91V[a\x02\x08a\tJV[a\x01\xF3a\nMV[a\x02-a\x0B\x18V[`@Q\x90\x15\x15\x81R` \x01a\x01SV[a\x02Ea\x0B\xE8V[\0[a\x01\x84a\r-V[a\x02Ea\r\x98V[`\x1FTa\x02-\x90`\xFF\x16\x81V[a\x01\xC9a\x02r6`\x04a\x17\x0EV[a\x0F\x0FV[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x0FRV[\x94\x93PPPPV[``_a\x02\xD0\x85\x85\x85a\x02wV[\x90P_[a\x02\xDE\x85\x85a\x1BBV[\x81\x10\x15a\x03+W\x82\x82\x82\x81Q\x81\x10a\x02\xF8Wa\x02\xF8a\x1BUV[` \x02` \x01\x01Q`@Q` \x01a\x03\x11\x92\x91\x90a\x1B\x99V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x02\xD4V[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\xCAW\x83\x82\x90_R` _ \x01\x80Ta\x04?\x90a\x1B\xADV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x04k\x90a\x1B\xADV[\x80\x15a\x04\xB6W\x80`\x1F\x10a\x04\x8DWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x04\xB6V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x04\x99W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x04\"V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x03\xC4V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x10\xB3V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x06V\x90a\x1B\xADV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06\x82\x90a\x1B\xADV[\x80\x15a\x06\xCDW\x80`\x1F\x10a\x06\xA4Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x06\xCDV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x06\xB0W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07dW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x07\x11W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x06&V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x01\x80Ta\x07\xBC\x90a\x1B\xADV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07\xE8\x90a\x1B\xADV[\x80\x15a\x083W\x80`\x1F\x10a\x08\nWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x083V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x08\x16W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x07\x9FV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\t2W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x08\xDFW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x08jV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\n5W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\t\xE2W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\tmV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x01\x80Ta\n\x8D\x90a\x1B\xADV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n\xB9\x90a\x1B\xADV[\x80\x15a\x0B\x04W\x80`\x1F\x10a\n\xDBWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\x04V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\n\xE7W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\npV[`\x08T_\x90`\xFF\x16\x15a\x0B/WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0B\xBDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\xE1\x91\x90a\x1B\xFEV[\x14\x15\x90P\x90V[`@\x80Q\x80\x82\x01\x82R`\r\x81R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x0Ci\x91\x90`\x04\x01a\x18&V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0C\x80W__\xFD[PZ\xF1\x15\x80\x15a\x0C\x92W=__>=_\xFD[PP`\x1FT`@Q\x7F`\xB5\xC3\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\x82\x01Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92Pc`\xB5\xC3\x90\x91P`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\r\x06W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r*\x91\x90a\x1B\xFEV[PV[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[_a\r\xDA`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01\x7Fchain\0\0\0\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_`\x06a\x05\xC0V[\x90P_a\x0E\x1E`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01\x7Fchain\0\0\0\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_`\x06a\x0F\x0FV[\x90P_[`\x06\x81\x10\x15a\x0F\nWa\x0F\x02`\x1F`\x01\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`\xB5\xC3\x90\x85\x84\x81Q\x81\x10a\x0E~Wa\x0E~a\x1BUV[` \x02` \x01\x01Q`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0E\xA4\x91\x81R` \x01\x90V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\xBFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\xE3\x91\x90a\x1B\xFEV[\x83\x83\x81Q\x81\x10a\x0E\xF5Wa\x0E\xF5a\x1BUV[` \x02` \x01\x01Qa\x12\x01V[`\x01\x01a\x0E\"V[PPPV[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x12\x84V[``a\x0F^\x84\x84a\x1BBV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0FvWa\x0Fva\x16\x89V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0F\xA9W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x0F\x94W\x90P[P\x90P\x83[\x83\x81\x10\x15a\x10\xAAWa\x10|\x86a\x0F\xC3\x83a\x13\xD2V[\x85`@Q` \x01a\x0F\xD6\x93\x92\x91\x90a\x1C\x15V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x0F\xF2\x90a\x1B\xADV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x10\x1E\x90a\x1B\xADV[\x80\x15a\x10iW\x80`\x1F\x10a\x10@Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x10iV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x10LW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x15\x03\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x10\x87\x87\x84a\x1BBV[\x81Q\x81\x10a\x10\x97Wa\x10\x97a\x1BUV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x0F\xAEV[P\x94\x93PPPPV[``a\x10\xBF\x84\x84a\x1BBV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10\xD7Wa\x10\xD7a\x16\x89V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x11\0W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x10\xAAWa\x11\xD3\x86a\x11\x1A\x83a\x13\xD2V[\x85`@Q` \x01a\x11-\x93\x92\x91\x90a\x1C\x15V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x11I\x90a\x1B\xADV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x11u\x90a\x1B\xADV[\x80\x15a\x11\xC0W\x80`\x1F\x10a\x11\x97Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x11\xC0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x11\xA3W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x15\xA2\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x11\xDE\x87\x84a\x1BBV[\x81Q\x81\x10a\x11\xEEWa\x11\xEEa\x1BUV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x11\x05V[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x12jW__\xFD[PZ\xFA\x15\x80\x15a\x12|W=__>=_\xFD[PPPPPPV[``a\x12\x90\x84\x84a\x1BBV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\xA8Wa\x12\xA8a\x16\x89V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x12\xD1W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x10\xAAWa\x13\xA4\x86a\x12\xEB\x83a\x13\xD2V[\x85`@Q` \x01a\x12\xFE\x93\x92\x91\x90a\x1C\x15V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x13\x1A\x90a\x1B\xADV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x13F\x90a\x1B\xADV[\x80\x15a\x13\x91W\x80`\x1F\x10a\x13hWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x13\x91V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x13tW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x165\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x13\xAF\x87\x84a\x1BBV[\x81Q\x81\x10a\x13\xBFWa\x13\xBFa\x1BUV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x12\xD6V[``\x81_\x03a\x14\x14WPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x14=W\x80a\x14'\x81a\x1C\xB2V[\x91Pa\x146\x90P`\n\x83a\x1D\x16V[\x91Pa\x14\x17V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x14WWa\x14Wa\x16\x89V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x14\x81W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x02\xBAWa\x14\x96`\x01\x83a\x1BBV[\x91Pa\x14\xA3`\n\x86a\x1D)V[a\x14\xAE\x90`0a\x1D=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x15\x99\x91\x90\x81\x01\x90a\x1D|V[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x15\xF6\x90\x86\x90\x86\x90`\x04\x01a\x1DOV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x16\x11W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x15\x99\x91\x90a\x1B\xFEV[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x15\xF6\x90\x86\x90\x86\x90`\x04\x01a\x1DOV[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x16\xDFWa\x16\xDFa\x16\x89V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x17\0Wa\x17\0a\x16\x89V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x17 W__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x176W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x17FW__\xFD[\x805a\x17Ya\x17T\x82a\x16\xE7V[a\x16\xB6V[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x17mW__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x18\x1AW`?\x19\x87\x86\x03\x01\x84Ra\x18\x05\x85\x83Qa\x17\x95V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x17\xE9V[P\x92\x96\x95PPPPPPV[` \x81R_a\x15\x99` \x83\x01\x84a\x17\x95V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x18\x85W\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\x18QV[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x18\xDEW`\x1F\x19\x85\x84\x03\x01\x88Ra\x18\xC8\x83\x83Qa\x17\x95V[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x18\xACV[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x18\x1AW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x19X`@\x87\x01\x82a\x18\x90V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x19\x10V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x18\x85W\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x19\x87V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x19\xF7W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x19\xB7V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x18\x1AW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x1AM`@\x88\x01\x82a\x17\x95V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x1Ah\x81\x83a\x19\xA5V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1A'V[` \x81R_a\x15\x99` \x83\x01\x84a\x18\x90V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x18\x1AW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1A\xFF`@\x87\x01\x82a\x19\xA5V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1A\xB7V[\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\x15\x9CWa\x15\x9Ca\x1B\x15V[\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x02\xBAa\x1B\xA7\x83\x86a\x1B\x82V[\x84a\x1B\x82V[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1B\xC1W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x1B\xF8W\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x1C\x0EW__\xFD[PQ\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\x81R_a\x1CF`\x01\x83\x01\x86a\x1B\x82V[\x7F[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x1Cv`\x01\x82\x01\x86a\x1B\x82V[\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\x81Ra\x1C\xA8`\x02\x82\x01\x85a\x1B\x82V[\x96\x95PPPPPPV[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x1C\xE2Wa\x1C\xE2a\x1B\x15V[P`\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`\x12`\x04R`$_\xFD[_\x82a\x1D$Wa\x1D$a\x1C\xE9V[P\x04\x90V[_\x82a\x1D7Wa\x1D7a\x1C\xE9V[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a\x15\x9CWa\x15\x9Ca\x1B\x15V[`@\x81R_a\x1Da`@\x83\x01\x85a\x17\x95V[\x82\x81\x03` \x84\x01Ra\x1Ds\x81\x85a\x17\x95V[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x1D\x8CW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xA2W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x1D\xB2W__\xFD[\x80Qa\x1D\xC0a\x17T\x82a\x16\xE7V[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a\x1D\xD4W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV\xFE\xA2dipfsX\"\x12 \xAE\xE7\xFEBH,\xB5\x88V:\xB8\xDC\x8C\x14\x82\xDF\xBA2\xF7\t\xFB9c\x87\x1D\x10\xDFX\x010\xB1\xFCdsolcC\0\x08\x1C\x003", + b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xFBW_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\x93W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x01\xBBW\x80c\xF9\xCE\x0EZ\x14a\x01\xC3W\x80c\xFAv&\xD4\x14a\x01\xD6W\x80c\xFC\x0CTj\x14a\x01\xE3W__\xFD[\x80c\x91j\x17\xC6\x14a\x01~W\x80c\xB0FO\xDC\x14a\x01\x93W\x80c\xB5P\x8A\xA9\x14a\x01\x9BW\x80c\xBAAO\xA6\x14a\x01\xA3W__\xFD[\x80c>^<#\x11a\0\xCEW\x80c>^<#\x14a\x01DW\x80c?r\x86\xF4\x14a\x01LW\x80cf\xD9\xA9\xA0\x14a\x01TW\x80c\x85\"l\x81\x14a\x01iW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x15\xBC\xF6[\x14a\x01\tW\x80c\x1E\xD7\x83\x1C\x14a\x01\x11W\x80c*\xDE8\x80\x14a\x01/W[__\xFD[a\x01\x07a\x02-V[\0[a\x01\x07a\x02jV[a\x01\x19a\x07)V[`@Qa\x01&\x91\x90a\x12\xFEV[`@Q\x80\x91\x03\x90\xF3[a\x017a\x07\x96V[`@Qa\x01&\x91\x90a\x13\x84V[a\x01\x19a\x08\xDFV[a\x01\x19a\tJV[a\x01\\a\t\xB5V[`@Qa\x01&\x91\x90a\x14\xD4V[a\x01qa\x0B.V[`@Qa\x01&\x91\x90a\x15RV[a\x01\x86a\x0B\xF9V[`@Qa\x01&\x91\x90a\x15\xA9V[a\x01\x86a\x0C\xFCV[a\x01qa\r\xFFV[a\x01\xABa\x0E\xCAV[`@Q\x90\x15\x15\x81R` \x01a\x01&V[a\x01\x19a\x0F\x9AV[a\x01\x07a\x01\xD16`\x04a\x16UV[a\x10\x05V[`\x1FTa\x01\xAB\x90`\xFF\x16\x81V[`\x1FTa\x02\x08\x90a\x01\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[`@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&V[a\x02hbeY\xC7sZ\x8E\x97t\xD6\x7F\xE8F\xC6\xF41\x1C\x07>*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x10\x05V[V[_sT\x1F\xD7IA\x9C\xA8\x06\xA8\xBC}\xA8\xAC#\xD3F\xF2\xDF\x8Bw\x90P_s\xCC\tf\xD8A\x8DA,Y\x9Ad!\xB7`\xA8G\xEB\x16\x9A\x8C\x90P_sI\xB0r\x15\x85d\xDB60E\x18\xFF\xA3{\x1C\xFC\x13\x91j\x90s\xBAF\xFC\xC1kFM\x97\x871Ag\xBD\xD9\xF1\xCE(@[\xA1\x7FVdR\x02@\xA4kK>\x96U\xC2\x0C\xC3\xF9\xE0\x84\x96\xA9\xB7F\xA4x\xE4v\xAE>\x04\xD6\xC8\xFC1\x7Fh\x99\xA7\xE1;e_\xA3g \x8C\xB2|n\xAA$\x107\r\x15e\xDC\x1F_\x11\x85:\x1E\x8C\xBE\xF03\x86\x86`@Qa\x03\x15\x90a\x12\xD7V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x96\x87\x16\x81R\x94\x86\x16` \x86\x01R`@\x85\x01\x93\x90\x93R``\x84\x01\x91\x90\x91R\x83\x16`\x80\x83\x01R\x90\x91\x16`\xA0\x82\x01R`\xC0\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03rW=__>=_\xFD[P\x90P_r\xB6~H\x05\x13\x83%\xCE\x87\x1D^'\xDC\x15\xF9\x94h\x1B\xC1so\n\xFA\xDE\x16\xBF\xD2\xE7\xF5QV4\xF2\xD0\xE3\xCD\x03\xC8E\xEF`@Qa\x03\xAB\x90a\x12\xE4V[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03\xE8W=__>=_\xFD[P\x90P_\x82\x82`@Qa\x03\xFA\x90a\x12\xF1V[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x047W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xB1W__\xFD[PZ\xF1\x15\x80\x15a\x04\xC3W=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x05FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05j\x91\x90a\x16\x96V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05\xFEW__\xFD[PZ\xF1\x15\x80\x15a\x06\x10W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x06mW__\xFD[PZ\xF1\x15\x80\x15a\x06\x7FW=__>=_\xFD[PP`@Q\x7Ft\xD1E\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\x81R`\x01`\x04\x82\x01Ra\x07\"\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x91Pct\xD1E\xB7\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xF0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x14\x91\x90a\x16\xBCV[g\r\xE0\xB6\xB3\xA7d\0\0a\x12TV[PPPPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07\x8CW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x07aW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x08\xBFW\x83\x82\x90_R` _ \x01\x80Ta\x084\x90a\x16\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x08`\x90a\x16\xD3V[\x80\x15a\x08\xABW\x80`\x1F\x10a\x08\x82Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x08\xABV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x08\x8EW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x08\x17V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07\xB9V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07\x8CW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x07aWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07\x8CW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x07aWPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\n\x08\x90a\x16\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n4\x90a\x16\xD3V[\x80\x15a\n\x7FW\x80`\x1F\x10a\nVWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\x7FV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\nbW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x0B\x16W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\n\xC3W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\t\xD8V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W\x83\x82\x90_R` _ \x01\x80Ta\x0Bn\x90a\x16\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\x9A\x90a\x16\xD3V[\x80\x15a\x0B\xE5W\x80`\x1F\x10a\x0B\xBCWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\xE5V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xC8W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0BQV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\xE4W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C\x91W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0C\x1CV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\xE7W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\x94W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\r\x1FV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W\x83\x82\x90_R` _ \x01\x80Ta\x0E?\x90a\x16\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0Ek\x90a\x16\xD3V[\x80\x15a\x0E\xB6W\x80`\x1F\x10a\x0E\x8DWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0E\xB6V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0E\x99W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0E\"V[`\x08T_\x90`\xFF\x16\x15a\x0E\xE1WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0FoW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\x93\x91\x90a\x16\xBCV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07\x8CW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x07aWPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\xA0W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x10\xC7\x91\x90\x81\x01\x90a\x17QV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x10\xE5\x92\x91\x90a\x18\x05V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11\x01W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11%\x91\x90a\x16\xBCV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x11\x9EW__\xFD[PZ\xF1\x15\x80\x15a\x11\xB0W=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x120W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\"\x91\x90a\x16\x96V[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x12\xBDW__\xFD[PZ\xFA\x15\x80\x15a\x12\xCFW=__>=_\xFD[PPPPPPV[a\x0F-\x80a\x18'\x839\x01\x90V[a\x0C\xF5\x80a'T\x839\x01\x90V[a\r \x80a4I\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x13KW\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\x13\x17V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14lW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x14RW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x14<\x84\x86Qa\x13VV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x14\x02V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x13\xAAV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x14\xCAW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x14\x8AV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14lW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x15 `@\x88\x01\x82a\x13VV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x15;\x81\x83a\x14xV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\xFAV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14lW`?\x19\x87\x86\x03\x01\x84Ra\x15\x94\x85\x83Qa\x13VV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15xV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14lW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x16\x17`@\x87\x01\x82a\x14xV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\xCFV[\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\x16PW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x16hW__\xFD[\x845\x93Pa\x16x` \x86\x01a\x16-V[\x92Pa\x16\x86`@\x86\x01a\x16-V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[_` \x82\x84\x03\x12\x15a\x16\xA6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x16\xB5W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x16\xCCW__\xFD[PQ\x91\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x16\xE7W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x17\x1EW\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[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\x17aW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17wW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x17\x87W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17\xA1Wa\x17\xA1a\x17$V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x17\xD1Wa\x17\xD1a\x17$V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x17\xE8W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x18\x17`@\x83\x01\x85a\x13VV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFEa\x01@`@R4\x80\x15a\0\x10W__\xFD[P`@Qa\x0F-8\x03\x80a\x0F-\x839\x81\x01`@\x81\x90Ra\0/\x91a\0sV[`\x01`\x01`\xA0\x1B\x03\x95\x86\x16`\x80R\x93\x85\x16`\xA0R`\xC0\x92\x90\x92R`\xE0R\x82\x16a\x01\0R\x16a\x01 Ra\0\xE3V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0pW__\xFD[PV[______`\xC0\x87\x89\x03\x12\x15a\0\x88W__\xFD[\x86Qa\0\x93\x81a\0\\V[` \x88\x01Q\x90\x96Pa\0\xA4\x81a\0\\V[`@\x88\x01Q``\x89\x01Q`\x80\x8A\x01Q\x92\x97P\x90\x95P\x93Pa\0\xC4\x81a\0\\V[`\xA0\x88\x01Q\x90\x92Pa\0\xD5\x81a\0\\V[\x80\x91PP\x92\x95P\x92\x95P\x92\x95V[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\r\xC6a\x01g_9_\x81\x81a\x01.\x01R\x81\x81a\x04\xFC\x01Ra\x05>\x01R_\x81\x81a\x01U\x01Ra\x03R\x01R_\x81\x81a\x01\xB1\x01Ra\x03\xC1\x01R_\x81\x81a\x01|\x01Ra\x02\x88\x01R_\x81\x81`\xDF\x01R\x81\x81a\x03t\x01Ra\x03\xF0\x01R_\x81\x81`\x8E\x01R\x81\x81a\x02;\x01Ra\x02\xB7\x01Ra\r\xC6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\x85W_5`\xE0\x1C\x80c\xADt}\xE6\x11a\0XW\x80c\xADt}\xE6\x14a\x01)W\x80c\xB9\x93|\xCB\x14a\x01PW\x80c\xC8\xC7\xF7\x01\x14a\x01wW\x80c\xE3L\xEF\x86\x14a\x01\xACW__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0\x89W\x80cN=\xF3\xF4\x14a\0\xDAW\x80cPcL\x0E\x14a\x01\x01W\x80c\x7F\x81O5\x14a\x01\x16W[__\xFD[a\0\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\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\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\x81V[a\x01\x14a\x01\x0F6`\x04a\x0BgV[a\x01\xD3V[\0[a\x01\x14a\x01$6`\x04a\x0C)V[a\x01\xFDV[a\0\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\x81V[a\0\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\x81V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xD1V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\xE8\x91\x90a\x0C\xADV[\x90Pa\x01\xF6\x85\x85\x85\x84a\x01\xFDV[PPPPPV[a\x02\x1Fs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x9AV[a\x02`s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x036\x91\x90a\x0C\xD1V[\x90Pa\x03\x99s\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\x7F\0\0\0\0\0\0\0\0\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\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x82\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04KW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04o\x91\x90a\x0C\xD1V[\x83Q\x90\x91P\x81\x10\x15a\x04\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[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\x85\x83a\x07YV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x06X\x90\x85\x90\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\x90`\x84\x01[`@\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\x07\xB4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF6\x91\x90a\x0C\xD1V[a\x07\0\x91\x90a\x0C\xE8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x06X\x90\x85\x90\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\x90`d\x01a\x05\xF4V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07\xAF\x90\x84\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\x90`d\x01a\x05\xF4V[PPPV[_a\x08\x15\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\x08\xBF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\xAFW\x80\x80` \x01\x90Q\x81\x01\x90a\x083\x91\x90a\r&V[a\x07\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\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\x04\xD9V[``a\x08\xCD\x84\x84_\x85a\x08\xD7V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\tiW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x04\xD9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\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`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x04\xD9V[__\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\n\x0F\x91\x90a\rEV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\nIW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\nNV[``\x91P[P\x91P\x91Pa\n^\x82\x82\x86a\niV[\x97\x96PPPPPPPV[``\x83\x15a\nxWP\x81a\x08\xD0V[\x82Q\x15a\n\x88W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x04\xD9\x91\x90a\r[V[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\xDDW__\xFD[PV[\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\x0B0Wa\x0B0a\n\xE0V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0B_Wa\x0B_a\n\xE0V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0BzW__\xFD[\x845a\x0B\x85\x81a\n\xBCV[\x93P` \x85\x015\x92P`@\x85\x015a\x0B\x9C\x81a\n\xBCV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xB7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\x0B\xC7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xE1Wa\x0B\xE1a\n\xE0V[a\x0B\xF4` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0B6V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0C\x08W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0C=W__\xFD[\x855a\x0CH\x81a\n\xBCV[\x94P` \x86\x015\x93P`@\x86\x015a\x0C_\x81a\n\xBCV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0C\x90W__\xFD[Pa\x0C\x99a\x0B\rV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0C\xBEW__\xFD[Pa\x0C\xC7a\x0B\rV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C\xE1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\r 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[_` \x82\x84\x03\x12\x15a\r6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x08\xD0W__\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\xFE\xA2dipfsX\"\x12 \xD28\x8C\xB3\xDCz\xA6\xF5\xA2\xEBuA}\x11\x05\x9B\xE1<\x8C\x9E\xAB\xE5\xD7\xEA\xDB\x1BV\x1F\x93\x7F\xF6\x91dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x0C\xF58\x03\x80a\x0C\xF5\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\x1Ea\0\xD7_9_\x81\x81`\xBB\x01R\x81\x81a\x01\x98\x01Ra\x02\xDB\x01R_\x81\x81a\x01\x07\x01R\x81\x81a\x01\xC2\x01R\x81\x81a\x02q\x01Ra\x03\x14\x01Ra\x0C\x1E_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0dW_5`\xE0\x1C\x80c\x7F\x81O5\x11a\0MW\x80c\x7F\x81O5\x14a\0\xA3W\x80c\xA6\xAA\x9C\xC0\x14a\0\xB6W\x80c\xC9F\x1AD\x14a\x01\x02W__\xFD[\x80cPcL\x0E\x14a\0hW\x80ct\xD1E\xB7\x14a\0}W[__\xFD[a\0{a\0v6`\x04a\t\xAAV[a\x01)V[\0[a\0\x90a\0\x8B6`\x04a\nlV[a\x01SV[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0{a\0\xB16`\x04a\n\x87V[a\x023V[a\0\xDD\x7F\0\0\0\0\0\0\0\0\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\0\x9AV[a\0\xDD\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01>\x91\x90a\x0B\x0BV[\x90Pa\x01L\x85\x85\x85\x84a\x023V[PPPPPV[`@Q\x7Fz~\r\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\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\x7F\0\0\0\0\0\0\0\0\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`$\x83\x01R_\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\x90\x91\x16\x90cz~\r\x92\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\tW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02-\x91\x90a\x0B/V[\x92\x91PPV[a\x02Us\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x043V[a\x02\x96s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\xF7V[`@Q\x7F\xE4hB\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\x83\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\x81\x16`$\x83\x01R\x85\x81\x16`D\x83\x01R`d\x82\x01\x85\x90R_\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\x90\x91\x16\x90c\xE4hB\xB7\x90`\x84\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\\W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x80\x91\x90a\x0B/V[\x82Q\x90\x91P\x81\x10\x15a\x03\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q_\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xF1\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xF2V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05kW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x8F\x91\x90a\x0B/V[a\x05\x99\x91\x90a\x0BFV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xF1\x90\x85\x90\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\x90`d\x01a\x04\x8DV[_a\x06S\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\x07\x02\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\xFDW\x80\x80` \x01\x90Q\x81\x01\x90a\x06q\x91\x90a\x0B~V[a\x06\xFDW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[PPPV[``a\x07\x10\x84\x84_\x85a\x07\x1AV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xACW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08*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\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x03\xEAV[__\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\x08R\x91\x90a\x0B\x9DV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x8CW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x91V[``\x91P[P\x91P\x91Pa\x08\xA1\x82\x82\x86a\x08\xACV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xBBWP\x81a\x07\x13V[\x82Q\x15a\x08\xCBW\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\xEA\x91\x90a\x0B\xB3V[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\t W__\xFD[PV[\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\tsWa\tsa\t#V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xA2Wa\t\xA2a\t#V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xBDW__\xFD[\x845a\t\xC8\x81a\x08\xFFV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xDF\x81a\x08\xFFV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xFAW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\nW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n$Wa\n$a\t#V[a\n7` `\x1F\x19`\x1F\x84\x01\x16\x01a\tyV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nKW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[_` \x82\x84\x03\x12\x15a\n|W__\xFD[\x815a\x07\x13\x81a\x08\xFFV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x9BW__\xFD[\x855a\n\xA6\x81a\x08\xFFV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xBD\x81a\x08\xFFV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xEEW__\xFD[Pa\n\xF7a\tPV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x1CW__\xFD[Pa\x0B%a\tPV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B?W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02-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[_` \x82\x84\x03\x12\x15a\x0B\x8EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x13W__\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\xFE\xA2dipfsX\"\x12 1\xA9_\tS$\x80\xC4eD\\\xF1\xA5F\x84\x08w?\xBD\x88\xEC\xC5\xCAl\x9C\xCA\x82\xDE\xCAb4\x08dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r 8\x03\x80a\r \x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CJa\0\xD6_9_\x81\x81`{\x01R\x81\x81a\x03u\x01Ra\x03\xF5\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0CJ_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cPcL\x0E\x14a\0NW\x80c\x7F\x81O5\x14a\0cW\x80c\xA6\xAA\x9C\xC0\x14a\0vW\x80c\xF2#L\xF9\x14a\0\xC6W[__\xFD[a\0aa\0\\6`\x04a\t\xD0V[a\0\xEDV[\0[a\0aa\0q6`\x04a\n\x92V[a\x01\x17V[a\0\x9D\x7F\0\0\0\0\0\0\0\0\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\x9D\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 ;\xBE\xA4\0\nXD\x11.v'\xBB\xE5\xECgi\x01\x98\xF0\xDF\xD9,\xA6^&\r\xB6\x93\x85\x0Bf\xA8dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 (\x9F\xC0L\xB8\xC0\x0E\x14\xCF\xB1\x04\xF5\xC8F\xD3\x8C\xA3\x05\x19Y:K\x02\xB7\xCF\xD6~\x1B\xA9\x96\xC7JdsolcC\0\x08\x1C\x003", ); #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] @@ -4054,64 +3970,6 @@ event logs(bytes); } } }; - /**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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolConstructor for constructorCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - } - }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. @@ -5034,31 +4892,17 @@ function failed() external view returns (bool); }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getBlockHeights(string,uint256,uint256)` and selector `0xfad06b8f`. + /**Function with signature `setUp()` and selector `0x0a9254e4`. ```solidity -function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); +function setUp() external; ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getBlockHeightsCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getBlockHeights(string,uint256,uint256)`](getBlockHeightsCall) function. + pub struct setUpCall; + ///Container type for the return parameters of the [`setUp()`](setUpCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getBlockHeightsReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >, - } + pub struct setUpReturn {} #[allow( non_camel_case_types, non_snake_case, @@ -5069,17 +4913,9 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte use alloy::sol_types as alloy_sol_types; { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - 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::String, - 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( @@ -5093,34 +4929,24 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsCall) -> Self { - (value.chainName, value.from, value.to) + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpCall) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getBlockHeightsCall { + impl ::core::convert::From> for setUpCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } + Self } } } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); + type UnderlyingSolTuple<'a> = (); #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >, - ); + type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -5134,42 +4960,39 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsReturn) -> Self { - (value.elements,) + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpReturn) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> - for getBlockHeightsReturn { + impl ::core::convert::From> for setUpReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } + Self {} } } } + impl setUpReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } #[automatically_derived] - impl alloy_sol_types::SolCall for getBlockHeightsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); + impl alloy_sol_types::SolCall for setUpCall { + type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); + type Return = setUpReturn; + type ReturnTuple<'a> = (); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getBlockHeights(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [250u8, 208u8, 107u8, 143u8]; + const SIGNATURE: &'static str = "setUp()"; + const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -5178,35 +5001,18 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte } #[inline] fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) + () } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) + setUpReturn::_tokenize(ret) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) + .map(Into::into) } #[inline] fn abi_decode_returns_validate( @@ -5215,40 +5021,32 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) + .map(Into::into) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getDigestLes(string,uint256,uint256)` and selector `0x44badbb6`. + /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. ```solidity -function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); +function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getDigestLesCall { + pub struct simulateForkAndTransferCall { + #[allow(missing_docs)] + pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, + pub sender: alloy::sol_types::private::Address, #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, + pub receiver: alloy::sol_types::private::Address, #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, + pub amount: alloy::sol_types::private::primitives::aliases::U256, } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getDigestLes(string,uint256,uint256)`](getDigestLesCall) function. + ///Container type for the return parameters of the [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getDigestLesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >, - } + pub struct simulateForkAndTransferReturn {} #[allow( non_camel_case_types, non_snake_case, @@ -5260,14 +5058,16 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa { #[doc(hidden)] 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::Uint<256>, ); #[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::primitives::aliases::U256, ); #[cfg(test)] @@ -5283,36 +5083,31 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesCall) -> Self { - (value.chainName, value.from, value.to) + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferCall) -> Self { + (value.forkAtBlock, value.sender, value.receiver, value.amount) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getDigestLesCall { + impl ::core::convert::From> + for simulateForkAndTransferCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, + forkAtBlock: tuple.0, + sender: tuple.1, + receiver: tuple.2, + amount: tuple.3, } } } } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array< - alloy::sol_types::sol_data::FixedBytes<32>, - >, - ); + type UnderlyingSolTuple<'a> = (); #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >, - ); + type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -5326,228 +5121,48 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesReturn) -> Self { - (value.elements,) + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferReturn) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getDigestLesReturn { + impl ::core::convert::From> + for simulateForkAndTransferReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } + Self {} } } } - #[automatically_derived] - impl alloy_sol_types::SolCall for getDigestLesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array< - alloy::sol_types::sol_data::FixedBytes<32>, - >, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getDigestLes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [68u8, 186u8, 219u8, 182u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaderHexes(string,uint256,uint256)` and selector `0x0813852a`. -```solidity -function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaderHexes(string,uint256,uint256)`](getHeaderHexesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeaderHexesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getHeaderHexesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } + impl simulateForkAndTransferReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () } } #[automatically_derived] - impl alloy_sol_types::SolCall for getHeaderHexesCall { + impl alloy_sol_types::SolCall for simulateForkAndTransferCall { type Parameters<'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::Uint<256>, ); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Bytes, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); + type Return = simulateForkAndTransferReturn; + type ReturnTuple<'a> = (); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaderHexes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [8u8, 19u8, 133u8, 42u8]; + const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; + const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -5557,210 +5172,30 @@ function getHeaderHexes(string memory chainName, uint256 from, uint256 to) exter #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - ::tokenize( - &self.chainName, - ), as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaders(string,uint256,uint256)` and selector `0x1c0da81f`. -```solidity -function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaders(string,uint256,uint256)`](getHeadersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersReturn { - #[allow(missing_docs)] - pub headers: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersReturn) -> Self { - (value.headers,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { headers: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getHeadersCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Bytes; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaders(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [28u8, 13u8, 168u8, 31u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, + > as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), + ::tokenize( + &self.sender, + ), + ::tokenize( + &self.receiver, ), as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), + > as alloy_sol_types::SolType>::tokenize(&self.amount), ) } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) + simulateForkAndTransferReturn::_tokenize(ret) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) + .map(Into::into) } #[inline] fn abi_decode_returns_validate( @@ -5769,10 +5204,7 @@ function getHeaders(string memory chainName, uint256 from, uint256 to) external as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) + .map(Into::into) } } }; @@ -6726,17 +6158,17 @@ function targetSenders() external view returns (address[] memory targetedSenders }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testFindHeightOfExistingBlocks()` and selector `0xf4b0eff0`. + /**Function with signature `testPellBedrockLSTStrategy()` and selector `0x15bcf65b`. ```solidity -function testFindHeightOfExistingBlocks() external view; +function testPellBedrockLSTStrategy() external; ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testFindHeightOfExistingBlocksCall; - ///Container type for the return parameters of the [`testFindHeightOfExistingBlocks()`](testFindHeightOfExistingBlocksCall) function. + pub struct testPellBedrockLSTStrategyCall; + ///Container type for the return parameters of the [`testPellBedrockLSTStrategy()`](testPellBedrockLSTStrategyCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testFindHeightOfExistingBlocksReturn {} + pub struct testPellBedrockLSTStrategyReturn {} #[allow( non_camel_case_types, non_snake_case, @@ -6763,16 +6195,16 @@ function testFindHeightOfExistingBlocks() external view; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: testFindHeightOfExistingBlocksCall) -> Self { + fn from(value: testPellBedrockLSTStrategyCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for testFindHeightOfExistingBlocksCall { + for testPellBedrockLSTStrategyCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -6796,43 +6228,43 @@ function testFindHeightOfExistingBlocks() external view; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: testFindHeightOfExistingBlocksReturn) -> Self { + fn from(value: testPellBedrockLSTStrategyReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for testFindHeightOfExistingBlocksReturn { + for testPellBedrockLSTStrategyReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } } } - impl testFindHeightOfExistingBlocksReturn { + impl testPellBedrockLSTStrategyReturn { fn _tokenize( &self, - ) -> ::ReturnToken< + ) -> ::ReturnToken< '_, > { () } } #[automatically_derived] - impl alloy_sol_types::SolCall for testFindHeightOfExistingBlocksCall { + impl alloy_sol_types::SolCall for testPellBedrockLSTStrategyCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testFindHeightOfExistingBlocksReturn; + type Return = testPellBedrockLSTStrategyReturn; type ReturnTuple<'a> = (); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testFindHeightOfExistingBlocks()"; - const SELECTOR: [u8; 4] = [244u8, 176u8, 239u8, 240u8]; + const SIGNATURE: &'static str = "testPellBedrockLSTStrategy()"; + const SELECTOR: [u8; 4] = [21u8, 188u8, 246u8, 91u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -6845,7 +6277,7 @@ function testFindHeightOfExistingBlocks() external view; } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testFindHeightOfExistingBlocksReturn::_tokenize(ret) + testPellBedrockLSTStrategyReturn::_tokenize(ret) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { @@ -6867,17 +6299,22 @@ function testFindHeightOfExistingBlocks() external view; }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testFindUnknownBlock()` and selector `0xc72ed5eb`. + /**Function with signature `token()` and selector `0xfc0c546a`. ```solidity -function testFindUnknownBlock() external; +function token() external view returns (address); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testFindUnknownBlockCall; - ///Container type for the return parameters of the [`testFindUnknownBlock()`](testFindUnknownBlockCall) function. + pub struct tokenCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`token()`](tokenCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testFindUnknownBlockReturn {} + pub struct tokenReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } #[allow( non_camel_case_types, non_snake_case, @@ -6904,16 +6341,14 @@ function testFindUnknownBlock() external; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testFindUnknownBlockCall) -> Self { + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> - for testFindUnknownBlockCall { + impl ::core::convert::From> for tokenCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -6921,9 +6356,9 @@ function testFindUnknownBlock() external; } { #[doc(hidden)] - 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( @@ -6937,43 +6372,32 @@ function testFindUnknownBlock() external; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testFindUnknownBlockReturn) -> Self { - () + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenReturn) -> Self { + (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> - for testFindUnknownBlockReturn { + impl ::core::convert::From> for tokenReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} + Self { _0: tuple.0 } } } } - impl testFindUnknownBlockReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } #[automatically_derived] - impl alloy_sol_types::SolCall for testFindUnknownBlockCall { + impl alloy_sol_types::SolCall for tokenCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testFindUnknownBlockReturn; - type ReturnTuple<'a> = (); + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testFindUnknownBlock()"; - const SELECTOR: [u8; 4] = [199u8, 46u8, 213u8, 235u8]; + const SIGNATURE: &'static str = "token()"; + const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -6986,14 +6410,21 @@ function testFindUnknownBlock() external; } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testFindUnknownBlockReturn::_tokenize(ret) + ( + ::tokenize( + ret, + ), + ) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) } #[inline] fn abi_decode_returns_validate( @@ -7002,14 +6433,17 @@ function testFindUnknownBlock() external; as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) } } }; - ///Container for all the [`FullRelayFindHeightTest`](self) function calls. + ///Container for all the [`PellBedRockLSTStrategyForked`](self) function calls. #[derive(serde::Serialize, serde::Deserialize)] #[derive()] - pub enum FullRelayFindHeightTestCalls { + pub enum PellBedRockLSTStrategyForkedCalls { #[allow(missing_docs)] IS_TEST(IS_TESTCall), #[allow(missing_docs)] @@ -7023,13 +6457,9 @@ function testFindUnknownBlock() external; #[allow(missing_docs)] failed(failedCall), #[allow(missing_docs)] - getBlockHeights(getBlockHeightsCall), - #[allow(missing_docs)] - getDigestLes(getDigestLesCall), + setUp(setUpCall), #[allow(missing_docs)] - getHeaderHexes(getHeaderHexesCall), - #[allow(missing_docs)] - getHeaders(getHeadersCall), + simulateForkAndTransfer(simulateForkAndTransferCall), #[allow(missing_docs)] targetArtifactSelectors(targetArtifactSelectorsCall), #[allow(missing_docs)] @@ -7043,12 +6473,12 @@ function testFindUnknownBlock() external; #[allow(missing_docs)] targetSenders(targetSendersCall), #[allow(missing_docs)] - testFindHeightOfExistingBlocks(testFindHeightOfExistingBlocksCall), + testPellBedrockLSTStrategy(testPellBedrockLSTStrategyCall), #[allow(missing_docs)] - testFindUnknownBlock(testFindUnknownBlockCall), + token(tokenCall), } #[automatically_derived] - impl FullRelayFindHeightTestCalls { + impl PellBedRockLSTStrategyForkedCalls { /// All the selectors of this enum. /// /// Note that the selectors might not be in the same order as the variants. @@ -7056,31 +6486,29 @@ function testFindUnknownBlock() external; /// /// Prefer using `SolInterface` methods instead. pub const SELECTORS: &'static [[u8; 4usize]] = &[ - [8u8, 19u8, 133u8, 42u8], - [28u8, 13u8, 168u8, 31u8], + [10u8, 146u8, 84u8, 228u8], + [21u8, 188u8, 246u8, 91u8], [30u8, 215u8, 131u8, 28u8], [42u8, 222u8, 56u8, 128u8], [62u8, 94u8, 60u8, 35u8], [63u8, 114u8, 134u8, 244u8], - [68u8, 186u8, 219u8, 182u8], [102u8, 217u8, 169u8, 160u8], [133u8, 34u8, 108u8, 129u8], [145u8, 106u8, 23u8, 198u8], [176u8, 70u8, 79u8, 220u8], [181u8, 80u8, 138u8, 169u8], [186u8, 65u8, 79u8, 166u8], - [199u8, 46u8, 213u8, 235u8], [226u8, 12u8, 159u8, 113u8], - [244u8, 176u8, 239u8, 240u8], + [249u8, 206u8, 14u8, 90u8], [250u8, 118u8, 38u8, 212u8], - [250u8, 208u8, 107u8, 143u8], + [252u8, 12u8, 84u8, 106u8], ]; } #[automatically_derived] - impl alloy_sol_types::SolInterface for FullRelayFindHeightTestCalls { - const NAME: &'static str = "FullRelayFindHeightTestCalls"; + impl alloy_sol_types::SolInterface for PellBedRockLSTStrategyForkedCalls { + const NAME: &'static str = "PellBedRockLSTStrategyForkedCalls"; const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 18usize; + const COUNT: usize = 16usize; #[inline] fn selector(&self) -> [u8; 4] { match self { @@ -7098,17 +6526,9 @@ function testFindUnknownBlock() external; ::SELECTOR } Self::failed(_) => ::SELECTOR, - Self::getBlockHeights(_) => { - ::SELECTOR - } - Self::getDigestLes(_) => { - ::SELECTOR - } - Self::getHeaderHexes(_) => { - ::SELECTOR - } - Self::getHeaders(_) => { - ::SELECTOR + Self::setUp(_) => ::SELECTOR, + Self::simulateForkAndTransfer(_) => { + ::SELECTOR } Self::targetArtifactSelectors(_) => { ::SELECTOR @@ -7128,12 +6548,10 @@ function testFindUnknownBlock() external; Self::targetSenders(_) => { ::SELECTOR } - Self::testFindHeightOfExistingBlocks(_) => { - ::SELECTOR - } - Self::testFindUnknownBlock(_) => { - ::SELECTOR + Self::testPellBedrockLSTStrategy(_) => { + ::SELECTOR } + Self::token(_) => ::SELECTOR, } } #[inline] @@ -7152,202 +6570,180 @@ function testFindUnknownBlock() external; ) -> alloy_sol_types::Result { static DECODE_SHIMS: &[fn( &[u8], - ) -> alloy_sol_types::Result] = &[ + ) -> alloy_sol_types::Result] = &[ { - fn getHeaderHexes( + fn setUp( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayFindHeightTestCalls::getHeaderHexes) + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(PellBedRockLSTStrategyForkedCalls::setUp) } - getHeaderHexes + setUp }, { - fn getHeaders( + fn testPellBedrockLSTStrategy( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( + ) -> alloy_sol_types::Result { + ::abi_decode_raw( data, ) - .map(FullRelayFindHeightTestCalls::getHeaders) + .map( + PellBedRockLSTStrategyForkedCalls::testPellBedrockLSTStrategy, + ) } - getHeaders + testPellBedrockLSTStrategy }, { fn excludeSenders( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayFindHeightTestCalls::excludeSenders) + .map(PellBedRockLSTStrategyForkedCalls::excludeSenders) } excludeSenders }, { fn targetInterfaces( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayFindHeightTestCalls::targetInterfaces) + .map(PellBedRockLSTStrategyForkedCalls::targetInterfaces) } targetInterfaces }, { fn targetSenders( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayFindHeightTestCalls::targetSenders) + .map(PellBedRockLSTStrategyForkedCalls::targetSenders) } targetSenders }, { fn targetContracts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayFindHeightTestCalls::targetContracts) + .map(PellBedRockLSTStrategyForkedCalls::targetContracts) } targetContracts }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayFindHeightTestCalls::getDigestLes) - } - getDigestLes - }, { fn targetArtifactSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayFindHeightTestCalls::targetArtifactSelectors) + .map( + PellBedRockLSTStrategyForkedCalls::targetArtifactSelectors, + ) } targetArtifactSelectors }, { fn targetArtifacts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayFindHeightTestCalls::targetArtifacts) + .map(PellBedRockLSTStrategyForkedCalls::targetArtifacts) } targetArtifacts }, { fn targetSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayFindHeightTestCalls::targetSelectors) + .map(PellBedRockLSTStrategyForkedCalls::targetSelectors) } targetSelectors }, { fn excludeSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayFindHeightTestCalls::excludeSelectors) + .map(PellBedRockLSTStrategyForkedCalls::excludeSelectors) } excludeSelectors }, { fn excludeArtifacts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayFindHeightTestCalls::excludeArtifacts) + .map(PellBedRockLSTStrategyForkedCalls::excludeArtifacts) } excludeArtifacts }, { fn failed( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw(data) - .map(FullRelayFindHeightTestCalls::failed) + .map(PellBedRockLSTStrategyForkedCalls::failed) } failed }, - { - fn testFindUnknownBlock( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayFindHeightTestCalls::testFindUnknownBlock) - } - testFindUnknownBlock - }, { fn excludeContracts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayFindHeightTestCalls::excludeContracts) + .map(PellBedRockLSTStrategyForkedCalls::excludeContracts) } excludeContracts }, { - fn testFindHeightOfExistingBlocks( + fn simulateForkAndTransfer( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( + ) -> alloy_sol_types::Result { + ::abi_decode_raw( data, ) .map( - FullRelayFindHeightTestCalls::testFindHeightOfExistingBlocks, + PellBedRockLSTStrategyForkedCalls::simulateForkAndTransfer, ) } - testFindHeightOfExistingBlocks + simulateForkAndTransfer }, { fn IS_TEST( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw(data) - .map(FullRelayFindHeightTestCalls::IS_TEST) + .map(PellBedRockLSTStrategyForkedCalls::IS_TEST) } IS_TEST }, { - fn getBlockHeights( + fn token( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayFindHeightTestCalls::getBlockHeights) + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(PellBedRockLSTStrategyForkedCalls::token) } - getBlockHeights + token }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { @@ -7368,206 +6764,188 @@ function testFindUnknownBlock() external; ) -> alloy_sol_types::Result { static DECODE_VALIDATE_SHIMS: &[fn( &[u8], - ) -> alloy_sol_types::Result] = &[ + ) -> alloy_sol_types::Result] = &[ { - fn getHeaderHexes( + fn setUp( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( data, ) - .map(FullRelayFindHeightTestCalls::getHeaderHexes) + .map(PellBedRockLSTStrategyForkedCalls::setUp) } - getHeaderHexes + setUp }, { - fn getHeaders( + fn testPellBedrockLSTStrategy( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( data, ) - .map(FullRelayFindHeightTestCalls::getHeaders) + .map( + PellBedRockLSTStrategyForkedCalls::testPellBedrockLSTStrategy, + ) } - getHeaders + testPellBedrockLSTStrategy }, { fn excludeSenders( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindHeightTestCalls::excludeSenders) + .map(PellBedRockLSTStrategyForkedCalls::excludeSenders) } excludeSenders }, { fn targetInterfaces( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindHeightTestCalls::targetInterfaces) + .map(PellBedRockLSTStrategyForkedCalls::targetInterfaces) } targetInterfaces }, { fn targetSenders( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindHeightTestCalls::targetSenders) + .map(PellBedRockLSTStrategyForkedCalls::targetSenders) } targetSenders }, { fn targetContracts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindHeightTestCalls::targetContracts) + .map(PellBedRockLSTStrategyForkedCalls::targetContracts) } targetContracts }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayFindHeightTestCalls::getDigestLes) - } - getDigestLes - }, { fn targetArtifactSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindHeightTestCalls::targetArtifactSelectors) + .map( + PellBedRockLSTStrategyForkedCalls::targetArtifactSelectors, + ) } targetArtifactSelectors }, { fn targetArtifacts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindHeightTestCalls::targetArtifacts) + .map(PellBedRockLSTStrategyForkedCalls::targetArtifacts) } targetArtifacts }, { fn targetSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindHeightTestCalls::targetSelectors) + .map(PellBedRockLSTStrategyForkedCalls::targetSelectors) } targetSelectors }, { fn excludeSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindHeightTestCalls::excludeSelectors) + .map(PellBedRockLSTStrategyForkedCalls::excludeSelectors) } excludeSelectors }, { fn excludeArtifacts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindHeightTestCalls::excludeArtifacts) + .map(PellBedRockLSTStrategyForkedCalls::excludeArtifacts) } excludeArtifacts }, { fn failed( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindHeightTestCalls::failed) + .map(PellBedRockLSTStrategyForkedCalls::failed) } failed }, - { - fn testFindUnknownBlock( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayFindHeightTestCalls::testFindUnknownBlock) - } - testFindUnknownBlock - }, { fn excludeContracts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindHeightTestCalls::excludeContracts) + .map(PellBedRockLSTStrategyForkedCalls::excludeContracts) } excludeContracts }, { - fn testFindHeightOfExistingBlocks( + fn simulateForkAndTransfer( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( data, ) .map( - FullRelayFindHeightTestCalls::testFindHeightOfExistingBlocks, + PellBedRockLSTStrategyForkedCalls::simulateForkAndTransfer, ) } - testFindHeightOfExistingBlocks + simulateForkAndTransfer }, { fn IS_TEST( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindHeightTestCalls::IS_TEST) + .map(PellBedRockLSTStrategyForkedCalls::IS_TEST) } IS_TEST }, { - fn getBlockHeights( + fn token( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( data, ) - .map(FullRelayFindHeightTestCalls::getBlockHeights) + .map(PellBedRockLSTStrategyForkedCalls::token) } - getBlockHeights + token }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { @@ -7609,24 +6987,14 @@ function testFindUnknownBlock() external; Self::failed(inner) => { ::abi_encoded_size(inner) } - Self::getBlockHeights(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getDigestLes(inner) => { - ::abi_encoded_size( - inner, - ) + Self::setUp(inner) => { + ::abi_encoded_size(inner) } - Self::getHeaderHexes(inner) => { - ::abi_encoded_size( + Self::simulateForkAndTransfer(inner) => { + ::abi_encoded_size( inner, ) } - Self::getHeaders(inner) => { - ::abi_encoded_size(inner) - } Self::targetArtifactSelectors(inner) => { ::abi_encoded_size( inner, @@ -7657,15 +7025,13 @@ function testFindUnknownBlock() external; inner, ) } - Self::testFindHeightOfExistingBlocks(inner) => { - ::abi_encoded_size( + Self::testPellBedrockLSTStrategy(inner) => { + ::abi_encoded_size( inner, ) } - Self::testFindUnknownBlock(inner) => { - ::abi_encoded_size( - inner, - ) + Self::token(inner) => { + ::abi_encoded_size(inner) } } } @@ -7702,26 +7068,11 @@ function testFindUnknownBlock() external; Self::failed(inner) => { ::abi_encode_raw(inner, out) } - Self::getBlockHeights(inner) => { - ::abi_encode_raw( - inner, - out, - ) + Self::setUp(inner) => { + ::abi_encode_raw(inner, out) } - Self::getDigestLes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaders(inner) => { - ::abi_encode_raw( + Self::simulateForkAndTransfer(inner) => { + ::abi_encode_raw( inner, out, ) @@ -7762,25 +7113,22 @@ function testFindUnknownBlock() external; out, ) } - Self::testFindHeightOfExistingBlocks(inner) => { - ::abi_encode_raw( + Self::testPellBedrockLSTStrategy(inner) => { + ::abi_encode_raw( inner, out, ) } - Self::testFindUnknownBlock(inner) => { - ::abi_encode_raw( - inner, - out, - ) + Self::token(inner) => { + ::abi_encode_raw(inner, out) } } } } - ///Container for all the [`FullRelayFindHeightTest`](self) events. + ///Container for all the [`PellBedRockLSTStrategyForked`](self) events. #[derive(serde::Serialize, serde::Deserialize)] #[derive()] - pub enum FullRelayFindHeightTestEvents { + pub enum PellBedRockLSTStrategyForkedEvents { #[allow(missing_docs)] log(log), #[allow(missing_docs)] @@ -7827,7 +7175,7 @@ function testFindUnknownBlock() external; logs(logs), } #[automatically_derived] - impl FullRelayFindHeightTestEvents { + impl PellBedRockLSTStrategyForkedEvents { /// All the selectors of this enum. /// /// Note that the selectors might not be in the same order as the variants. @@ -7948,8 +7296,8 @@ function testFindUnknownBlock() external; ]; } #[automatically_derived] - impl alloy_sol_types::SolEventInterface for FullRelayFindHeightTestEvents { - const NAME: &'static str = "FullRelayFindHeightTestEvents"; + impl alloy_sol_types::SolEventInterface for PellBedRockLSTStrategyForkedEvents { + const NAME: &'static str = "PellBedRockLSTStrategyForkedEvents"; const COUNT: usize = 22usize; fn decode_raw_log( topics: &[alloy_sol_types::Word], @@ -8127,7 +7475,7 @@ function testFindUnknownBlock() external; } } #[automatically_derived] - impl alloy_sol_types::private::IntoLogData for FullRelayFindHeightTestEvents { + impl alloy_sol_types::private::IntoLogData for PellBedRockLSTStrategyForkedEvents { fn to_log_data(&self) -> alloy_sol_types::private::LogData { match self { Self::log(inner) => { @@ -8270,9 +7618,9 @@ function testFindUnknownBlock() external; } } use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`FullRelayFindHeightTest`](self) contract instance. + /**Creates a new wrapper around an on-chain [`PellBedRockLSTStrategyForked`](self) contract instance. -See the [wrapper's documentation](`FullRelayFindHeightTestInstance`) for more details.*/ +See the [wrapper's documentation](`PellBedRockLSTStrategyForkedInstance`) for more details.*/ #[inline] pub const fn new< P: alloy_contract::private::Provider, @@ -8280,8 +7628,8 @@ See the [wrapper's documentation](`FullRelayFindHeightTestInstance`) for more de >( address: alloy_sol_types::private::Address, provider: P, - ) -> FullRelayFindHeightTestInstance { - FullRelayFindHeightTestInstance::::new(address, provider) + ) -> PellBedRockLSTStrategyForkedInstance { + PellBedRockLSTStrategyForkedInstance::::new(address, provider) } /**Deploys this contract using the given `provider` and constructor arguments, if any. @@ -8295,9 +7643,9 @@ For more fine-grained control over the deployment process, use [`deploy_builder` >( provider: P, ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, + Output = alloy_contract::Result>, > { - FullRelayFindHeightTestInstance::::deploy(provider) + PellBedRockLSTStrategyForkedInstance::::deploy(provider) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` and constructor arguments, if any. @@ -8309,12 +7657,12 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ P: alloy_contract::private::Provider, N: alloy_contract::private::Network, >(provider: P) -> alloy_contract::RawCallBuilder { - FullRelayFindHeightTestInstance::::deploy_builder(provider) + PellBedRockLSTStrategyForkedInstance::::deploy_builder(provider) } - /**A [`FullRelayFindHeightTest`](self) instance. + /**A [`PellBedRockLSTStrategyForked`](self) instance. Contains type-safe methods for interacting with an on-chain instance of the -[`FullRelayFindHeightTest`](self) contract located at a given `address`, using a given +[`PellBedRockLSTStrategyForked`](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!) @@ -8323,7 +7671,7 @@ 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 FullRelayFindHeightTestInstance< + pub struct PellBedRockLSTStrategyForkedInstance< P, N = alloy_contract::private::Ethereum, > { @@ -8332,10 +7680,10 @@ See the [module-level documentation](self) for all the available methods.*/ _network: ::core::marker::PhantomData, } #[automatically_derived] - impl ::core::fmt::Debug for FullRelayFindHeightTestInstance { + impl ::core::fmt::Debug for PellBedRockLSTStrategyForkedInstance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("FullRelayFindHeightTestInstance") + f.debug_tuple("PellBedRockLSTStrategyForkedInstance") .field(&self.address) .finish() } @@ -8345,10 +7693,10 @@ See the [module-level documentation](self) for all the available methods.*/ impl< P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - > FullRelayFindHeightTestInstance { - /**Creates a new wrapper around an on-chain [`FullRelayFindHeightTest`](self) contract instance. + > PellBedRockLSTStrategyForkedInstance { + /**Creates a new wrapper around an on-chain [`PellBedRockLSTStrategyForked`](self) contract instance. -See the [wrapper's documentation](`FullRelayFindHeightTestInstance`) for more details.*/ +See the [wrapper's documentation](`PellBedRockLSTStrategyForkedInstance`) for more details.*/ #[inline] pub const fn new( address: alloy_sol_types::private::Address, @@ -8368,7 +7716,7 @@ For more fine-grained control over the deployment process, use [`deploy_builder` #[inline] pub async fn deploy( provider: P, - ) -> alloy_contract::Result> { + ) -> alloy_contract::Result> { let call_builder = Self::deploy_builder(provider); let contract_address = call_builder.deploy().await?; Ok(Self::new(contract_address, call_builder.provider)) @@ -8406,11 +7754,11 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ &self.provider } } - impl FullRelayFindHeightTestInstance<&P, N> { + impl PellBedRockLSTStrategyForkedInstance<&P, N> { /// Clones the provider and returns a new instance with the cloned provider. #[inline] - pub fn with_cloned_provider(self) -> FullRelayFindHeightTestInstance { - FullRelayFindHeightTestInstance { + pub fn with_cloned_provider(self) -> PellBedRockLSTStrategyForkedInstance { + PellBedRockLSTStrategyForkedInstance { address: self.address, provider: ::core::clone::Clone::clone(&self.provider), _network: ::core::marker::PhantomData, @@ -8422,7 +7770,7 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ impl< P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - > FullRelayFindHeightTestInstance { + > PellBedRockLSTStrategyForkedInstance { /// 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 @@ -8465,63 +7813,24 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { self.call_builder(&failedCall) } - ///Creates a new call builder for the [`getBlockHeights`] function. - pub fn getBlockHeights( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getBlockHeightsCall, N> { - self.call_builder( - &getBlockHeightsCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getDigestLes`] function. - pub fn getDigestLes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getDigestLesCall, N> { - self.call_builder( - &getDigestLesCall { - chainName, - from, - to, - }, - ) + ///Creates a new call builder for the [`setUp`] function. + pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { + self.call_builder(&setUpCall) } - ///Creates a new call builder for the [`getHeaderHexes`] function. - pub fn getHeaderHexes( + ///Creates a new call builder for the [`simulateForkAndTransfer`] function. + pub fn simulateForkAndTransfer( &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeaderHexesCall, N> { + forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + sender: alloy::sol_types::private::Address, + receiver: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { self.call_builder( - &getHeaderHexesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaders`] function. - pub fn getHeaders( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeadersCall, N> { - self.call_builder( - &getHeadersCall { - chainName, - from, - to, + &simulateForkAndTransferCall { + forkAtBlock, + sender, + receiver, + amount, }, ) } @@ -8561,17 +7870,15 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { self.call_builder(&targetSendersCall) } - ///Creates a new call builder for the [`testFindHeightOfExistingBlocks`] function. - pub fn testFindHeightOfExistingBlocks( + ///Creates a new call builder for the [`testPellBedrockLSTStrategy`] function. + pub fn testPellBedrockLSTStrategy( &self, - ) -> alloy_contract::SolCallBuilder<&P, testFindHeightOfExistingBlocksCall, N> { - self.call_builder(&testFindHeightOfExistingBlocksCall) + ) -> alloy_contract::SolCallBuilder<&P, testPellBedrockLSTStrategyCall, N> { + self.call_builder(&testPellBedrockLSTStrategyCall) } - ///Creates a new call builder for the [`testFindUnknownBlock`] function. - pub fn testFindUnknownBlock( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testFindUnknownBlockCall, N> { - self.call_builder(&testFindUnknownBlockCall) + ///Creates a new call builder for the [`token`] function. + pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { + self.call_builder(&tokenCall) } } /// Event filters. @@ -8579,7 +7886,7 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ impl< P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - > FullRelayFindHeightTestInstance { + > PellBedRockLSTStrategyForkedInstance { /// 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. diff --git a/crates/bindings/src/fullrelayfindancestortest.rs b/crates/bindings/src/pell_bed_rock_strategy_forked.rs similarity index 63% rename from crates/bindings/src/fullrelayfindancestortest.rs rename to crates/bindings/src/pell_bed_rock_strategy_forked.rs index ac3b04ad8..13b114c3a 100644 --- a/crates/bindings/src/fullrelayfindancestortest.rs +++ b/crates/bindings/src/pell_bed_rock_strategy_forked.rs @@ -837,7 +837,7 @@ library StdInvariant { } } -interface FullRelayFindAncestorTest { +interface PellBedRockStrategyForked { event log(string); event log_address(address); event log_array(uint256[] val); @@ -861,37 +861,28 @@ interface FullRelayFindAncestorTest { event log_uint(uint256); event logs(bytes); - constructor(); - function IS_TEST() external view returns (bool); function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); function excludeContracts() external view returns (address[] memory excludedContracts_); function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); function excludeSenders() external view returns (address[] memory excludedSenders_); function failed() external view returns (bool); - function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); - function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); - function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); - function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); + function setUp() external; + function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); function targetArtifacts() external view returns (string[] memory targetedArtifacts_); function targetContracts() external view returns (address[] memory targetedContracts_); function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); function targetSenders() external view returns (address[] memory targetedSenders_); - function testFindKnownAncestor() external view; - function testFindUnknownAncestor() external; + function testPellBedrockStrategy() external; + function token() external view returns (address); } ``` ...which was generated by the following JSON ABI: ```json [ - { - "type": "constructor", - "inputs": [], - "stateMutability": "nonpayable" - }, { "type": "function", "name": "IS_TEST", @@ -984,119 +975,38 @@ interface FullRelayFindAncestorTest { }, { "type": "function", - "name": "getBlockHeights", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getDigestLes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes32[]", - "internalType": "bytes32[]" - } - ], - "stateMutability": "view" + "name": "setUp", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" }, { "type": "function", - "name": "getHeaderHexes", + "name": "simulateForkAndTransfer", "inputs": [ { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", + "name": "forkAtBlock", "type": "uint256", "internalType": "uint256" }, { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes[]", - "internalType": "bytes[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaders", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" + "name": "sender", + "type": "address", + "internalType": "address" }, { - "name": "from", - "type": "uint256", - "internalType": "uint256" + "name": "receiver", + "type": "address", + "internalType": "address" }, { - "name": "to", + "name": "amount", "type": "uint256", "internalType": "uint256" } ], - "outputs": [ - { - "name": "headers", - "type": "bytes", - "internalType": "bytes" - } - ], - "stateMutability": "view" + "outputs": [], + "stateMutability": "nonpayable" }, { "type": "function", @@ -1214,17 +1124,23 @@ interface FullRelayFindAncestorTest { }, { "type": "function", - "name": "testFindKnownAncestor", + "name": "testPellBedrockStrategy", "inputs": [], "outputs": [], - "stateMutability": "view" + "stateMutability": "nonpayable" }, { "type": "function", - "name": "testFindUnknownAncestor", + "name": "token", "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IERC20" + } + ], + "stateMutability": "view" }, { "type": "event", @@ -1599,28 +1515,28 @@ interface FullRelayFindAncestorTest { clippy::style, clippy::empty_structs_with_brackets )] -pub mod FullRelayFindAncestorTest { +pub mod PellBedRockStrategyForked { use super::*; use alloy::sol_types as alloy_sol_types; /// The creation / init bytecode of the contract. /// /// ```text - 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 + ///0x6080604052600c8054600160ff199182168117909255601f80549091169091179055348015602b575f5ffd5b50601f8054610100600160a81b0319167403c7054bcb39f7b2e5b2c7acb37583e32d70cfa300179055613f07806100615f395ff3fe608060405234801561000f575f5ffd5b50600436106100fb575f3560e01c80639590266911610093578063e20c9f7111610063578063e20c9f71146101bb578063f9ce0e5a146101c3578063fa7626d4146101d6578063fc0c546a146101e3575f5ffd5b8063959026691461018b578063b0464fdc14610193578063b5508aa91461019b578063ba414fa6146101a3575f5ffd5b80633f7286f4116100ce5780633f7286f41461014457806366d9a9a01461014c57806385226c8114610161578063916a17c614610176575f5ffd5b80630a9254e4146100ff5780631ed7831c146101095780632ade3880146101275780633e5e3c231461013c575b5f5ffd5b61010761022d565b005b61011161026a565b60405161011e9190611254565b60405180910390f35b61012f6102d7565b60405161011e91906112da565b610111610420565b61011161048b565b6101546104f6565b60405161011e919061142a565b61016961066f565b60405161011e91906114a8565b61017e61073a565b60405161011e91906114ff565b61010761083d565b61017e610c4b565b610169610d4e565b6101ab610e19565b604051901515815260200161011e565b610111610ee9565b6101076101d13660046115ab565b610f54565b601f546101ab9060ff1681565b601f5461020890610100900473ffffffffffffffffffffffffffffffffffffffff1681565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200161011e565b610268626559c7735a8e9774d67fe846c6f4311c073e2ac34b33646f73999999cf1046e68e36e1aa2e0e07105eddd1f08e6305f5e100610f54565b565b606060168054806020026020016040519081016040528092919081815260200182805480156102cd57602002820191905f5260205f20905b815473ffffffffffffffffffffffffffffffffffffffff1681526001909101906020018083116102a2575b5050505050905090565b6060601e805480602002602001604051908101604052809291908181526020015f905b82821015610417575f848152602080822060408051808201825260028702909201805473ffffffffffffffffffffffffffffffffffffffff168352600181018054835181870281018701909452808452939591948681019491929084015b82821015610400578382905f5260205f20018054610375906115ec565b80601f01602080910402602001604051908101604052809291908181526020018280546103a1906115ec565b80156103ec5780601f106103c3576101008083540402835291602001916103ec565b820191905f5260205f20905b8154815290600101906020018083116103cf57829003601f168201915b505050505081526020019060010190610358565b5050505081525050815260200190600101906102fa565b50505050905090565b606060188054806020026020016040519081016040528092919081815260200182805480156102cd57602002820191905f5260205f2090815473ffffffffffffffffffffffffffffffffffffffff1681526001909101906020018083116102a2575050505050905090565b606060178054806020026020016040519081016040528092919081815260200182805480156102cd57602002820191905f5260205f2090815473ffffffffffffffffffffffffffffffffffffffff1681526001909101906020018083116102a2575050505050905090565b6060601b805480602002602001604051908101604052809291908181526020015f905b82821015610417578382905f5260205f2090600202016040518060400160405290815f82018054610549906115ec565b80601f0160208091040260200160405190810160405280929190818152602001828054610575906115ec565b80156105c05780601f10610597576101008083540402835291602001916105c0565b820191905f5260205f20905b8154815290600101906020018083116105a357829003601f168201915b505050505081526020016001820180548060200260200160405190810160405280929190818152602001828054801561065757602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916815260200190600401906020826003010492830192600103820291508084116106045790505b50505050508152505081526020019060010190610519565b6060601a805480602002602001604051908101604052809291908181526020015f905b82821015610417578382905f5260205f200180546106af906115ec565b80601f01602080910402602001604051908101604052809291908181526020018280546106db906115ec565b80156107265780601f106106fd57610100808354040283529160200191610726565b820191905f5260205f20905b81548152906001019060200180831161070957829003601f168201915b505050505081526020019060010190610692565b6060601d805480602002602001604051908101604052809291908181526020015f905b82821015610417575f84815260209081902060408051808201825260028602909201805473ffffffffffffffffffffffffffffffffffffffff16835260018101805483518187028101870190945280845293949193858301939283018282801561082557602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916815260200190600401906020826003010492830192600103820291508084116107d25790505b5050505050815250508152602001906001019061075d565b5f732ac98db41cbd3172cb7b8fd8a8ab3b91cfe45dcf90505f816040516108639061122d565b73ffffffffffffffffffffffffffffffffffffffff9091168152602001604051809103905ff080158015610899573d5f5f3e3d5ffd5b5090505f72b67e4805138325ce871d5e27dc15f994681bc173631ae97e24f9f30150d31d958d37915975f12ed86040516108d29061123a565b73ffffffffffffffffffffffffffffffffffffffff928316815291166020820152604001604051809103905ff08015801561090f573d5f5f3e3d5ffd5b5090505f828260405161092190611247565b73ffffffffffffffffffffffffffffffffffffffff928316815291166020820152604001604051809103905ff08015801561095e573d5f5f3e3d5ffd5b506040517f06447d5600000000000000000000000000000000000000000000000000000000815273999999cf1046e68e36e1aa2e0e07105eddd1f08e6004820152909150737109709ecfa91a80626ff3989d68f67f5b1dd12d906306447d56906024015f604051808303815f87803b1580156109d8575f5ffd5b505af11580156109ea573d5f5f3e3d5ffd5b5050601f546040517f095ea7b300000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff85811660048301526305f5e1006024830152610100909204909116925063095ea7b391506044016020604051808303815f875af1158015610a6d573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610a91919061163d565b50601f54604080516020810182525f815290517f7f814f3500000000000000000000000000000000000000000000000000000000815261010090920473ffffffffffffffffffffffffffffffffffffffff90811660048401526305f5e10060248401526001604484015290516064830152821690637f814f35906084015f604051808303815f87803b158015610b25575f5ffd5b505af1158015610b37573d5f5f3e3d5ffd5b50505050737109709ecfa91a80626ff3989d68f67f5b1dd12d73ffffffffffffffffffffffffffffffffffffffff166390c5013b6040518163ffffffff1660e01b81526004015f604051808303815f87803b158015610b94575f5ffd5b505af1158015610ba6573d5f5f3e3d5ffd5b50506040517f74d145b700000000000000000000000000000000000000000000000000000000815260016004820152610c45925073ffffffffffffffffffffffffffffffffffffffff851691506374d145b790602401602060405180830381865afa158015610c17573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610c3b9190611663565b6305f5e1006111aa565b50505050565b6060601c805480602002602001604051908101604052809291908181526020015f905b82821015610417575f84815260209081902060408051808201825260028602909201805473ffffffffffffffffffffffffffffffffffffffff168352600181018054835181870281018701909452808452939491938583019392830182828015610d3657602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191681526020019060040190602082600301049283019260010382029150808411610ce35790505b50505050508152505081526020019060010190610c6e565b60606019805480602002602001604051908101604052809291908181526020015f905b82821015610417578382905f5260205f20018054610d8e906115ec565b80601f0160208091040260200160405190810160405280929190818152602001828054610dba906115ec565b8015610e055780601f10610ddc57610100808354040283529160200191610e05565b820191905f5260205f20905b815481529060010190602001808311610de857829003601f168201915b505050505081526020019060010190610d71565b6008545f9060ff1615610e30575060085460ff1690565b6040517f667f9d70000000000000000000000000000000000000000000000000000000008152737109709ecfa91a80626ff3989d68f67f5b1dd12d600482018190527f6661696c6564000000000000000000000000000000000000000000000000000060248301525f9163667f9d7090604401602060405180830381865afa158015610ebe573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610ee29190611663565b1415905090565b606060158054806020026020016040519081016040528092919081815260200182805480156102cd57602002820191905f5260205f2090815473ffffffffffffffffffffffffffffffffffffffff1681526001909101906020018083116102a2575050505050905090565b6040517ff877cb1900000000000000000000000000000000000000000000000000000000815260206004820152601760248201527f424f425f50524f445f5055424c49435f5250435f55524c0000000000000000006044820152737109709ecfa91a80626ff3989d68f67f5b1dd12d906371ee464d90829063f877cb19906064015f60405180830381865afa158015610fef573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d908101601f1916820160405261101691908101906116a7565b866040518363ffffffff1660e01b815260040161103492919061175b565b6020604051808303815f875af1158015611050573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906110749190611663565b506040517fca669fa700000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff84166004820152737109709ecfa91a80626ff3989d68f67f5b1dd12d9063ca669fa7906024015f604051808303815f87803b1580156110ed575f5ffd5b505af11580156110ff573d5f5f3e3d5ffd5b5050601f546040517fa9059cbb00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff868116600483015260248201869052610100909204909116925063a9059cbb91506044016020604051808303815f875af115801561117f573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906111a3919061163d565b5050505050565b6040517f98296c540000000000000000000000000000000000000000000000000000000081526004810183905260248101829052737109709ecfa91a80626ff3989d68f67f5b1dd12d906398296c54906044015f6040518083038186803b158015611213575f5ffd5b505afa158015611225573d5f5f3e3d5ffd5b505050505050565b610cd48061177d83390190565b610cf58061245183390190565b610d8c8061314683390190565b602080825282518282018190525f918401906040840190835b818110156112a157835173ffffffffffffffffffffffffffffffffffffffff1683526020938401939092019160010161126d565b509095945050505050565b5f81518084528060208401602086015e5f602082860101526020601f19601f83011685010191505092915050565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b828110156113c257603f198786030184528151805173ffffffffffffffffffffffffffffffffffffffff168652602090810151604082880181905281519088018190529101906060600582901b8801810191908801905f5b818110156113a8577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa08a85030183526113928486516112ac565b6020958601959094509290920191600101611358565b509197505050602094850194929092019150600101611300565b50929695505050505050565b5f8151808452602084019350602083015f5b828110156114205781517fffffffff00000000000000000000000000000000000000000000000000000000168652602095860195909101906001016113e0565b5093949350505050565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b828110156113c257603f19878603018452815180516040875261147660408801826112ac565b905060208201519150868103602088015261149181836113ce565b965050506020938401939190910190600101611450565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b828110156113c257603f198786030184526114ea8583516112ac565b945060209384019391909101906001016114ce565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b828110156113c257603f19878603018452815173ffffffffffffffffffffffffffffffffffffffff8151168652602081015190506040602087015261156d60408701826113ce565b9550506020938401939190910190600101611525565b803573ffffffffffffffffffffffffffffffffffffffff811681146115a6575f5ffd5b919050565b5f5f5f5f608085870312156115be575f5ffd5b843593506115ce60208601611583565b92506115dc60408601611583565b9396929550929360600135925050565b600181811c9082168061160057607f821691505b602082108103611637577f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b50919050565b5f6020828403121561164d575f5ffd5b8151801515811461165c575f5ffd5b9392505050565b5f60208284031215611673575f5ffd5b5051919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b5f602082840312156116b7575f5ffd5b815167ffffffffffffffff8111156116cd575f5ffd5b8201601f810184136116dd575f5ffd5b805167ffffffffffffffff8111156116f7576116f761167a565b604051601f19603f601f19601f8501160116810181811067ffffffffffffffff821117156117275761172761167a565b60405281815282820160200186101561173e575f5ffd5b8160208401602083015e5f91810160200191909152949350505050565b604081525f61176d60408301856112ac565b9050826020830152939250505056fe60a060405234801561000f575f5ffd5b50604051610cd4380380610cd483398101604081905261002e9161003f565b6001600160a01b031660805261006c565b5f6020828403121561004f575f5ffd5b81516001600160a01b0381168114610065575f5ffd5b9392505050565b608051610c3c6100985f395f81816070015281816101230152818161019401526101ee0152610c3c5ff3fe608060405234801561000f575f5ffd5b506004361061003f575f3560e01c806350634c0e146100435780637f814f3514610058578063fbfa77cf1461006b575b5f5ffd5b6100566100513660046109c2565b6100bb565b005b610056610066366004610a84565b6100e5565b6100927f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200160405180910390f35b5f818060200190518101906100d09190610b08565b90506100de858585846100e5565b5050505050565b61010773ffffffffffffffffffffffffffffffffffffffff85163330866103f5565b61014873ffffffffffffffffffffffffffffffffffffffff85167f0000000000000000000000000000000000000000000000000000000000000000856104b9565b6040517f40c10f1900000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8581166004830152602482018590527f000000000000000000000000000000000000000000000000000000000000000016906340c10f19906044015f604051808303815f87803b1580156101d5575f5ffd5b505af11580156101e7573d5f5f3e3d5ffd5b505050505f7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166359f3d39b6040518163ffffffff1660e01b8152600401602060405180830381865afa158015610255573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906102799190610b2c565b6040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201529091505f9073ffffffffffffffffffffffffffffffffffffffff8316906370a0823190602401602060405180830381865afa1580156102e6573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061030a9190610b47565b835190915081101561037d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601a60248201527f496e73756666696369656e74206f757470757420616d6f756e7400000000000060448201526064015b60405180910390fd5b61039e73ffffffffffffffffffffffffffffffffffffffff831685836105b4565b6040805173ffffffffffffffffffffffffffffffffffffffff84168152602081018390527f0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d910160405180910390a1505050505050565b60405173ffffffffffffffffffffffffffffffffffffffff808516602483015283166044820152606481018290526104b39085907f23b872dd00000000000000000000000000000000000000000000000000000000906084015b60408051601f198184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff000000000000000000000000000000000000000000000000000000009093169290921790915261060f565b50505050565b6040517fdd62ed3e00000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff83811660248301525f91839186169063dd62ed3e90604401602060405180830381865afa15801561052d573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906105519190610b47565b61055b9190610b5e565b60405173ffffffffffffffffffffffffffffffffffffffff85166024820152604481018290529091506104b39085907f095ea7b3000000000000000000000000000000000000000000000000000000009060640161044f565b60405173ffffffffffffffffffffffffffffffffffffffff831660248201526044810182905261060a9084907fa9059cbb000000000000000000000000000000000000000000000000000000009060640161044f565b505050565b5f610670826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff1661071a9092919063ffffffff16565b80519091501561060a578080602001905181019061068e9190610b9c565b61060a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f742073756363656564000000000000000000000000000000000000000000006064820152608401610374565b606061072884845f85610732565b90505b9392505050565b6060824710156107c4576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c00000000000000000000000000000000000000000000000000006064820152608401610374565b73ffffffffffffffffffffffffffffffffffffffff85163b610842576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606401610374565b5f5f8673ffffffffffffffffffffffffffffffffffffffff16858760405161086a9190610bbb565b5f6040518083038185875af1925050503d805f81146108a4576040519150601f19603f3d011682016040523d82523d5f602084013e6108a9565b606091505b50915091506108b98282866108c4565b979650505050505050565b606083156108d357508161072b565b8251156108e35782518084602001fd5b816040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016103749190610bd1565b73ffffffffffffffffffffffffffffffffffffffff81168114610938575f5ffd5b50565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b6040516020810167ffffffffffffffff8111828210171561098b5761098b61093b565b60405290565b604051601f8201601f1916810167ffffffffffffffff811182821017156109ba576109ba61093b565b604052919050565b5f5f5f5f608085870312156109d5575f5ffd5b84356109e081610917565b93506020850135925060408501356109f781610917565b9150606085013567ffffffffffffffff811115610a12575f5ffd5b8501601f81018713610a22575f5ffd5b803567ffffffffffffffff811115610a3c57610a3c61093b565b610a4f6020601f19601f84011601610991565b818152886020838501011115610a63575f5ffd5b816020840160208301375f6020838301015280935050505092959194509250565b5f5f5f5f8486036080811215610a98575f5ffd5b8535610aa381610917565b9450602086013593506040860135610aba81610917565b925060207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa082011215610aeb575f5ffd5b50610af4610968565b606095909501358552509194909350909190565b5f6020828403128015610b19575f5ffd5b50610b22610968565b9151825250919050565b5f60208284031215610b3c575f5ffd5b815161072b81610917565b5f60208284031215610b57575f5ffd5b5051919050565b80820180821115610b96577f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b92915050565b5f60208284031215610bac575f5ffd5b8151801515811461072b575f5ffd5b5f82518060208501845e5f920191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f8301168401019150509291505056fea26469706673582212208e1b0cef4a7ed003740a4ee4b7b6f3f4caf8cc471d3e7a392ca4d44b0c1b8d3c64736f6c634300081c003360c060405234801561000f575f5ffd5b50604051610cf5380380610cf583398101604081905261002e9161005c565b6001600160a01b039182166080521660a052610094565b6001600160a01b0381168114610059575f5ffd5b50565b5f5f6040838503121561006d575f5ffd5b825161007881610045565b602084015190925061008981610045565b809150509250929050565b60805160a051610c1e6100d75f395f818160bb0152818161019801526102db01525f8181610107015281816101c20152818161027101526103140152610c1e5ff3fe608060405234801561000f575f5ffd5b5060043610610064575f3560e01c80637f814f351161004d5780637f814f35146100a3578063a6aa9cc0146100b6578063c9461a4414610102575f5ffd5b806350634c0e1461006857806374d145b71461007d575b5f5ffd5b61007b6100763660046109aa565b610129565b005b61009061008b366004610a6c565b610153565b6040519081526020015b60405180910390f35b61007b6100b1366004610a87565b610233565b6100dd7f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200161009a565b6100dd7f000000000000000000000000000000000000000000000000000000000000000081565b5f8180602001905181019061013e9190610b0b565b905061014c85858584610233565b5050505050565b6040517f7a7e0d9200000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff82811660048301527f0000000000000000000000000000000000000000000000000000000000000000811660248301525f917f000000000000000000000000000000000000000000000000000000000000000090911690637a7e0d9290604401602060405180830381865afa158015610209573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061022d9190610b2f565b92915050565b61025573ffffffffffffffffffffffffffffffffffffffff8516333086610433565b61029673ffffffffffffffffffffffffffffffffffffffff85167f0000000000000000000000000000000000000000000000000000000000000000856104f7565b6040517fe46842b700000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff83811660048301527f0000000000000000000000000000000000000000000000000000000000000000811660248301528581166044830152606482018590525f917f00000000000000000000000000000000000000000000000000000000000000009091169063e46842b7906084016020604051808303815f875af115801561035c573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103809190610b2f565b82519091508110156103f3576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601a60248201527f496e73756666696369656e74206f757470757420616d6f756e7400000000000060448201526064015b60405180910390fd5b604080515f8152602081018390527f0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d910160405180910390a15050505050565b60405173ffffffffffffffffffffffffffffffffffffffff808516602483015283166044820152606481018290526104f19085907f23b872dd00000000000000000000000000000000000000000000000000000000906084015b60408051601f198184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff00000000000000000000000000000000000000000000000000000000909316929092179091526105f2565b50505050565b6040517fdd62ed3e00000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff83811660248301525f91839186169063dd62ed3e90604401602060405180830381865afa15801561056b573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061058f9190610b2f565b6105999190610b46565b60405173ffffffffffffffffffffffffffffffffffffffff85166024820152604481018290529091506104f19085907f095ea7b3000000000000000000000000000000000000000000000000000000009060640161048d565b5f610653826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166107029092919063ffffffff16565b8051909150156106fd57808060200190518101906106719190610b7e565b6106fd576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f7420737563636565640000000000000000000000000000000000000000000060648201526084016103ea565b505050565b606061071084845f8561071a565b90505b9392505050565b6060824710156107ac576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c000000000000000000000000000000000000000000000000000060648201526084016103ea565b73ffffffffffffffffffffffffffffffffffffffff85163b61082a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e747261637400000060448201526064016103ea565b5f5f8673ffffffffffffffffffffffffffffffffffffffff1685876040516108529190610b9d565b5f6040518083038185875af1925050503d805f811461088c576040519150601f19603f3d011682016040523d82523d5f602084013e610891565b606091505b50915091506108a18282866108ac565b979650505050505050565b606083156108bb575081610713565b8251156108cb5782518084602001fd5b816040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016103ea9190610bb3565b73ffffffffffffffffffffffffffffffffffffffff81168114610920575f5ffd5b50565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b6040516020810167ffffffffffffffff8111828210171561097357610973610923565b60405290565b604051601f8201601f1916810167ffffffffffffffff811182821017156109a2576109a2610923565b604052919050565b5f5f5f5f608085870312156109bd575f5ffd5b84356109c8816108ff565b93506020850135925060408501356109df816108ff565b9150606085013567ffffffffffffffff8111156109fa575f5ffd5b8501601f81018713610a0a575f5ffd5b803567ffffffffffffffff811115610a2457610a24610923565b610a376020601f19601f84011601610979565b818152886020838501011115610a4b575f5ffd5b816020840160208301375f6020838301015280935050505092959194509250565b5f60208284031215610a7c575f5ffd5b8135610713816108ff565b5f5f5f5f8486036080811215610a9b575f5ffd5b8535610aa6816108ff565b9450602086013593506040860135610abd816108ff565b925060207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa082011215610aee575f5ffd5b50610af7610950565b606095909501358552509194909350909190565b5f6020828403128015610b1c575f5ffd5b50610b25610950565b9151825250919050565b5f60208284031215610b3f575f5ffd5b5051919050565b8082018082111561022d577f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f60208284031215610b8e575f5ffd5b81518015158114610713575f5ffd5b5f82518060208501845e5f920191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f8301168401019150509291505056fea264697066735822122031a95f09532480c465445cf1a5468408773fbd88ecc5ca6c9cca82deca62340864736f6c634300081c003360c060405234801561000f575f5ffd5b50604051610d8c380380610d8c83398101604081905261002e9161005c565b6001600160a01b039182166080521660a052610094565b6001600160a01b0381168114610059575f5ffd5b50565b5f5f6040838503121561006d575f5ffd5b825161007881610045565b602084015190925061008981610045565b809150509250929050565b60805160a051610cb66100d65f395f818160cb015281816103e1015261046101525f8181605301528181610155015281816101df015261023b0152610cb65ff3fe608060405234801561000f575f5ffd5b506004361061004a575f3560e01c8063231710a51461004e57806350634c0e1461009e5780637f814f35146100b3578063a6aa9cc0146100c6575b5f5ffd5b6100757f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200160405180910390f35b6100b16100ac366004610a3c565b6100ed565b005b6100b16100c1366004610afe565b610117565b6100757f000000000000000000000000000000000000000000000000000000000000000081565b5f818060200190518101906101029190610b82565b905061011085858584610117565b5050505050565b61013973ffffffffffffffffffffffffffffffffffffffff85163330866104c0565b61017a73ffffffffffffffffffffffffffffffffffffffff85167f000000000000000000000000000000000000000000000000000000000000000085610584565b604080516020810182525f815290517f7f814f3500000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff868116600483015260248201869052306044830152915160648201527f000000000000000000000000000000000000000000000000000000000000000090911690637f814f35906084015f604051808303815f87803b158015610222575f5ffd5b505af1158015610234573d5f5f3e3d5ffd5b505050505f7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663fbfa77cf6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156102a2573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906102c69190610ba6565b73ffffffffffffffffffffffffffffffffffffffff166359f3d39b6040518163ffffffff1660e01b8152600401602060405180830381865afa15801561030e573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103329190610ba6565b6040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201529091505f9073ffffffffffffffffffffffffffffffffffffffff8316906370a0823190602401602060405180830381865afa15801561039f573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103c39190610bc1565b905061040673ffffffffffffffffffffffffffffffffffffffff83167f000000000000000000000000000000000000000000000000000000000000000083610584565b6040517f7f814f3500000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8381166004830152602482018390528581166044830152845160648301527f00000000000000000000000000000000000000000000000000000000000000001690637f814f35906084015f604051808303815f87803b1580156104a2575f5ffd5b505af11580156104b4573d5f5f3e3d5ffd5b50505050505050505050565b60405173ffffffffffffffffffffffffffffffffffffffff8085166024830152831660448201526064810182905261057e9085907f23b872dd00000000000000000000000000000000000000000000000000000000906084015b60408051601f198184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff000000000000000000000000000000000000000000000000000000009093169290921790915261067f565b50505050565b6040517fdd62ed3e00000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff83811660248301525f91839186169063dd62ed3e90604401602060405180830381865afa1580156105f8573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061061c9190610bc1565b6106269190610bd8565b60405173ffffffffffffffffffffffffffffffffffffffff851660248201526044810182905290915061057e9085907f095ea7b3000000000000000000000000000000000000000000000000000000009060640161051a565b5f6106e0826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166107949092919063ffffffff16565b80519091501561078f57808060200190518101906106fe9190610c16565b61078f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f7420737563636565640000000000000000000000000000000000000000000060648201526084015b60405180910390fd5b505050565b60606107a284845f856107ac565b90505b9392505050565b60608247101561083e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c00000000000000000000000000000000000000000000000000006064820152608401610786565b73ffffffffffffffffffffffffffffffffffffffff85163b6108bc576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606401610786565b5f5f8673ffffffffffffffffffffffffffffffffffffffff1685876040516108e49190610c35565b5f6040518083038185875af1925050503d805f811461091e576040519150601f19603f3d011682016040523d82523d5f602084013e610923565b606091505b509150915061093382828661093e565b979650505050505050565b6060831561094d5750816107a5565b82511561095d5782518084602001fd5b816040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107869190610c4b565b73ffffffffffffffffffffffffffffffffffffffff811681146109b2575f5ffd5b50565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b6040516020810167ffffffffffffffff81118282101715610a0557610a056109b5565b60405290565b604051601f8201601f1916810167ffffffffffffffff81118282101715610a3457610a346109b5565b604052919050565b5f5f5f5f60808587031215610a4f575f5ffd5b8435610a5a81610991565b9350602085013592506040850135610a7181610991565b9150606085013567ffffffffffffffff811115610a8c575f5ffd5b8501601f81018713610a9c575f5ffd5b803567ffffffffffffffff811115610ab657610ab66109b5565b610ac96020601f19601f84011601610a0b565b818152886020838501011115610add575f5ffd5b816020840160208301375f6020838301015280935050505092959194509250565b5f5f5f5f8486036080811215610b12575f5ffd5b8535610b1d81610991565b9450602086013593506040860135610b3481610991565b925060207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa082011215610b65575f5ffd5b50610b6e6109e2565b606095909501358552509194909350909190565b5f6020828403128015610b93575f5ffd5b50610b9c6109e2565b9151825250919050565b5f60208284031215610bb6575f5ffd5b81516107a581610991565b5f60208284031215610bd1575f5ffd5b5051919050565b80820180821115610c10577f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b92915050565b5f60208284031215610c26575f5ffd5b815180151581146107a5575f5ffd5b5f82518060208501845e5f920191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f8301168401019150509291505056fea264697066735822122023c69f1f346a137ebabd0583e0b1058f4ec6613b1c67b1203e014f1bb39b436764736f6c634300081c0033a264697066735822122080c46bf0c619ce077e3b885ae84d89b546f0e258b6e6e088e6ebd6386226909c64736f6c634300081c0033 /// ``` #[rustfmt::skip] #[allow(clippy::all)] pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"`\x80`@R`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15a\0,W__\xFD[P`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k42\xB0\xB22\xB99\x9759\xB7\xB7`\xA1\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k\x05\xCC\xEC\xAD\xCC\xAEm.e\xCD\x0C\xAF`\xA3\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x1D\x81R` \x01\x7F.fakePeriodStartHeader.height\0\0\0\x81RP`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01q.genesis.digest_le`p\x1B\x81RP__Q` aT\xE6_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x16c\xD90\xA0\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01!W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01H\x91\x90\x81\x01\x90a\t(V[\x90P_\x81\x86`@Q` \x01a\x01^\x92\x91\x90a\t\x83V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Rc`\xF9\xBB\x11`\xE0\x1B\x82R\x91P_Q` aT\xE6_9_Q\x90_R\x90c`\xF9\xBB\x11\x90a\x01\x9E\x90\x84\x90`\x04\x01a\t\xF5V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xB8W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01\xDF\x91\x90\x81\x01\x90a\t(V[` \x90a\x01\xEC\x90\x82a\n\x8BV[Pa\x02\x83\x85` \x80Ta\x01\xFE\x90a\n\x07V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02*\x90a\n\x07V[\x80\x15a\x02uW\x80`\x1F\x10a\x02LWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02uV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02XW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x04\xF1\x91PPV[a\x03\x19\x85` \x80Ta\x02\x94\x90a\n\x07V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\xC0\x90a\n\x07V[\x80\x15a\x03\x0BW\x80`\x1F\x10a\x02\xE2Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\x0BV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02\xEEW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x05p\x91PPV[a\x03\xAF\x85` \x80Ta\x03*\x90a\n\x07V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03V\x90a\n\x07V[\x80\x15a\x03\xA1W\x80`\x1F\x10a\x03xWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xA1V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\x84W\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x05\xE3\x91PPV[`@Qa\x03\xBB\x90a\x08\x92V[a\x03\xC7\x93\x92\x91\x90a\x0BEV[`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03\xE0W=__>=_\xFD[P`\x1F`\x01a\x01\0\n\x81T\x81`\x01`\x01`\xA0\x1B\x03\x02\x19\x16\x90\x83`\x01`\x01`\xA0\x1B\x03\x16\x02\x17\x90UPPPPPPP`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16ce\xDAA\xB9a\x04f`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k\x05\xCC\xEC\xAD\xCC\xAEm.e\xCD\x0C\xAF`\xA3\x1B\x81RP` \x80Ta\x01\xFE\x90a\n\x07V[`@\x80Q\x80\x82\x01\x90\x91R`\x05\x81Rd1\xB40\xB4\xB7`\xD9\x1B` \x82\x01Ra\x04\x8E\x90_`\x06a\x06\x17V[`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x04\xAB\x92\x91\x90a\x0BiV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\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\x0B\x8DV[Pa\x0C\xC8V[`@Qc\x1F\xB2C}`\xE3\x1B\x81R``\x90_Q` aT\xE6_9_Q\x90_R\x90c\xFD\x92\x1B\xE8\x90a\x05&\x90\x86\x90\x86\x90`\x04\x01a\x0BiV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05@W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x05g\x91\x90\x81\x01\x90a\t(V[\x90P[\x92\x91PPV[`@QcV\xEE\xF1[`\xE1\x1B\x81R_\x90_Q` aT\xE6_9_Q\x90_R\x90c\xAD\xDD\xE2\xB6\x90a\x05\xA4\x90\x86\x90\x86\x90`\x04\x01a\x0BiV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xBFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05g\x91\x90a\x0B\xB3V[`@Qc\x17w\xE5\x9D`\xE0\x1B\x81R_\x90_Q` aT\xE6_9_Q\x90_R\x90c\x17w\xE5\x9D\x90a\x05\xA4\x90\x86\x90\x86\x90`\x04\x01a\x0BiV[``_a\x06%\x85\x85\x85a\x06\x89V[\x90P_[a\x063\x85\x85a\x0B\xDEV[\x81\x10\x15a\x06\x80W\x82\x82\x82\x81Q\x81\x10a\x06MWa\x06Ma\x0B\xF1V[` \x02` \x01\x01Q`@Q` \x01a\x06f\x92\x91\x90a\x0C\x05V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x06)V[PP\x93\x92PPPV[``a\x06\xB8\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01b\r\x0C\xAF`\xEB\x1B\x81RPa\x06\xC0` \x1B` \x1CV[\x94\x93PPPPV[``a\x06\xCC\x84\x84a\x0B\xDEV[`\x01`\x01`@\x1B\x03\x81\x11\x15a\x06\xE3Wa\x06\xE3a\x08\x9FV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x07\x16W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x07\x01W\x90P[P\x90P\x83[\x83\x81\x10\x15a\x07\x8DWa\x07_\x86a\x070\x83a\x07\x96V[\x85`@Q` \x01a\x07C\x93\x92\x91\x90a\x0C\x19V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x01\xFE\x90a\n\x07V[\x82a\x07j\x87\x84a\x0B\xDEV[\x81Q\x81\x10a\x07zWa\x07za\x0B\xF1V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x07\x1BV[P\x94\x93PPPPV[``\x81_\x03a\x07\xBCWPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R`\x03`\xFC\x1B` \x82\x01R\x90V[\x81_[\x81\x15a\x07\xE5W\x80a\x07\xCF\x81a\x0CcV[\x91Pa\x07\xDE\x90P`\n\x83a\x0C\x8FV[\x91Pa\x07\xBFV[_\x81`\x01`\x01`@\x1B\x03\x81\x11\x15a\x07\xFEWa\x07\xFEa\x08\x9FV[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x08(W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x06\xB8Wa\x08=`\x01\x83a\x0B\xDEV[\x91Pa\x08J`\n\x86a\x0C\xA2V[a\x08U\x90`0a\x0C\xB5V[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x08jWa\x08ja\x0B\xF1V[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SPa\x08\x8B`\n\x86a\x0C\x8FV[\x94Pa\x08,V[a);\x80a+\xAB\x839\x01\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x80`\x01`\x01`@\x1B\x03\x84\x11\x15a\x08\xCCWa\x08\xCCa\x08\x9FV[P`@Q`\x1F\x19`\x1F\x85\x01\x81\x16`?\x01\x16\x81\x01\x81\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17\x15a\x08\xFAWa\x08\xFAa\x08\x9FV[`@R\x83\x81R\x90P\x80\x82\x84\x01\x85\x10\x15a\t\x11W__\xFD[\x83\x83` \x83\x01^_` \x85\x83\x01\x01RP\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\t8W__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\tMW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\t]W__\xFD[a\x06\xB8\x84\x82Q` \x84\x01a\x08\xB3V[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\t\x8E\x82\x85a\tlV[\x7F/test/fullRelay/testData/\0\0\0\0\0\0\0\x81Ra\t\xBE`\x19\x82\x01\x85a\tlV[\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R_a\x05g` \x83\x01\x84a\t\xC7V[`\x01\x81\x81\x1C\x90\x82\x16\x80a\n\x1BW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\n9WcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\n\x86W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\ndWP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\n\x83W_\x81U`\x01\x01a\npV[PP[PPPV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\n\xA4Wa\n\xA4a\x08\x9FV[a\n\xB8\x81a\n\xB2\x84Ta\n\x07V[\x84a\n?V[` `\x1F\x82\x11`\x01\x81\x14a\n\xEAW_\x83\x15a\n\xD3WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\n\x83V[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x0B\x19W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\n\xF9V[P\x84\x82\x10\x15a\x0B6W\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[``\x81R_a\x0BW``\x83\x01\x86a\t\xC7V[` \x83\x01\x94\x90\x94RP`@\x01R\x91\x90PV[`@\x81R_a\x0B{`@\x83\x01\x85a\t\xC7V[\x82\x81\x03` \x84\x01Ra\t\xBE\x81\x85a\t\xC7V[_` \x82\x84\x03\x12\x15a\x0B\x9DW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x0B\xACW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x0B\xC3W__\xFD[PQ\x91\x90PV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x05jWa\x05ja\x0B\xCAV[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[_a\x06\xB8a\x0C\x13\x83\x86a\tlV[\x84a\tlV[`\x17`\xF9\x1B\x81R_a\x0C.`\x01\x83\x01\x86a\tlV[`[`\xF8\x1B\x81Ra\x0CB`\x01\x82\x01\x86a\tlV[\x90Pa.\x97`\xF1\x1B\x81Ra\x0CY`\x02\x82\x01\x85a\tlV[\x96\x95PPPPPPV[_`\x01\x82\x01a\x0CtWa\x0Cta\x0B\xCAV[P`\x01\x01\x90V[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x0C\x9DWa\x0C\x9Da\x0C{V[P\x04\x90V[_\x82a\x0C\xB0Wa\x0C\xB0a\x0C{V[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a\x05jWa\x05ja\x0B\xCAV[a\x1E\xD6\x80a\x0C\xD5_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01/W_5`\xE0\x1C\x80c\x85\"l\x81\x11a\0\xADW\x80c\xB5P\x8A\xA9\x11a\0}W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x02OW\x80c\xFAv&\xD4\x14a\x02WW\x80c\xFA\xD0k\x8F\x14a\x02dW__\xFD[\x80c\xB5P\x8A\xA9\x14a\x02/W\x80c\xBAAO\xA6\x14a\x027W__\xFD[\x80c\x85\"l\x81\x14a\x01\xF5W\x80c\x91j\x17\xC6\x14a\x02\nW\x80c\x91\xAE\x19\xCA\x14a\x02\x1FW\x80c\xB0FO\xDC\x14a\x02'W__\xFD[\x80c>^<#\x11a\x01\x02W\x80cD\xBA\xDB\xB6\x11a\0\xE8W\x80cD\xBA\xDB\xB6\x14a\x01\xB6W\x80cFCe\x8E\x14a\x01\xD6W\x80cf\xD9\xA9\xA0\x14a\x01\xE0W__\xFD[\x80c>^<#\x14a\x01\xA6W\x80c?r\x86\xF4\x14a\x01\xAEW__\xFD[\x80c\x08\x13\x85*\x14a\x013W\x80c\x1C\r\xA8\x1F\x14a\x01\\W\x80c\x1E\xD7\x83\x1C\x14a\x01|W\x80c*\xDE8\x80\x14a\x01\x91W[__\xFD[a\x01Fa\x01A6`\x04a\x17\xBDV[a\x02wV[`@Qa\x01S\x91\x90a\x18rV[`@Q\x80\x91\x03\x90\xF3[a\x01oa\x01j6`\x04a\x17\xBDV[a\x02\xC2V[`@Qa\x01S\x91\x90a\x18\xD5V[a\x01\x84a\x034V[`@Qa\x01S\x91\x90a\x18\xE7V[a\x01\x99a\x03\xA1V[`@Qa\x01S\x91\x90a\x19\x99V[a\x01\x84a\x04\xEAV[a\x01\x84a\x05UV[a\x01\xC9a\x01\xC46`\x04a\x17\xBDV[a\x05\xC0V[`@Qa\x01S\x91\x90a\x1A\x1DV[a\x01\xDEa\x06\x03V[\0[a\x01\xE8a\x07OV[`@Qa\x01S\x91\x90a\x1A\xB0V[a\x01\xFDa\x08\xC8V[`@Qa\x01S\x91\x90a\x1B.V[a\x02\x12a\t\x93V[`@Qa\x01S\x91\x90a\x1B@V[a\x01\xDEa\n\x96V[a\x02\x12a\x0C\xB5V[a\x01\xFDa\r\xB8V[a\x02?a\x0E\x83V[`@Q\x90\x15\x15\x81R` \x01a\x01SV[a\x01\x84a\x0FSV[`\x1FTa\x02?\x90`\xFF\x16\x81V[a\x01\xC9a\x02r6`\x04a\x17\xBDV[a\x0F\xBEV[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x10\x01V[\x94\x93PPPPV[``_a\x02\xD0\x85\x85\x85a\x02wV[\x90P_[a\x02\xDE\x85\x85a\x1B\xF1V[\x81\x10\x15a\x03+W\x82\x82\x82\x81Q\x81\x10a\x02\xF8Wa\x02\xF8a\x1C\x04V[` \x02` \x01\x01Q`@Q` \x01a\x03\x11\x92\x91\x90a\x1CHV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x02\xD4V[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\xCAW\x83\x82\x90_R` _ \x01\x80Ta\x04?\x90a\x1C\\V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x04k\x90a\x1C\\V[\x80\x15a\x04\xB6W\x80`\x1F\x10a\x04\x8DWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x04\xB6V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x04\x99W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x04\"V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x03\xC4V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x11bV[`@\x80Q\x80\x82\x01\x82R`\x10\x81R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x06\x84\x91\x90`\x04\x01a\x18\xD5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x06\x9BW__\xFD[PZ\xF1\x15\x80\x15a\x06\xADW=__>=_\xFD[PP`\x1FT`@Q\x7F0\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\x82\x01R`\x03`$\x82\x01Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92Pc0\x01{;\x91P`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07(W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07L\x91\x90a\x1C\xADV[PV[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x07\xA2\x90a\x1C\\V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07\xCE\x90a\x1C\\V[\x80\x15a\x08\x19W\x80`\x1F\x10a\x07\xF0Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x08\x19V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\xFCW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x08\xB0W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x08]W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07rV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x01\x80Ta\t\x08\x90a\x1C\\V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\t4\x90a\x1C\\V[\x80\x15a\t\x7FW\x80`\x1F\x10a\tVWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\t\x7FV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\tbW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x08\xEBV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\n~W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\n+W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\t\xB6V[_a\n\xD8`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01\x7Fchain\0\0\0\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_`\x06a\x05\xC0V[\x90P_[`\x06\x81\x10\x15a\x0C\xB1Wa\x0B\xC5`\x1F`\x01\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\x16c0\x01{;\x84\x84\x81Q\x81\x10a\x0B8Wa\x0B8a\x1C\x04V[` \x02` \x01\x01Q_`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0Bg\x92\x91\x90\x91\x82R` \x82\x01R`@\x01\x90V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0B\x82W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\xA6\x91\x90a\x1C\xADV[\x83\x83\x81Q\x81\x10a\x0B\xB8Wa\x0B\xB8a\x1C\x04V[` \x02` \x01\x01Qa\x12\xB0V[\x80\x15a\x0C\xA9Wa\x0C\xA9`\x1F`\x01\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\x16c0\x01{;\x84\x84\x81Q\x81\x10a\x0C\x1EWa\x0C\x1Ea\x1C\x04V[` \x02` \x01\x01Q`\x01`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0CN\x92\x91\x90\x91\x82R` \x82\x01R`@\x01\x90V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0CiW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x8D\x91\x90a\x1C\xADV[\x83a\x0C\x99`\x01\x85a\x1B\xF1V[\x81Q\x81\x10a\x0B\xB8Wa\x0B\xB8a\x1C\x04V[`\x01\x01a\n\xDCV[PPV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\xA0W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\rMW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xD8V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x01\x80Ta\r\xF8\x90a\x1C\\V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0E$\x90a\x1C\\V[\x80\x15a\x0EoW\x80`\x1F\x10a\x0EFWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0EoV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0ERW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\r\xDBV[`\x08T_\x90`\xFF\x16\x15a\x0E\x9AWP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F(W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0FL\x91\x90a\x1C\xADV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x133V[``a\x10\r\x84\x84a\x1B\xF1V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10%Wa\x10%a\x178V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x10XW\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x10CW\x90P[P\x90P\x83[\x83\x81\x10\x15a\x11YWa\x11+\x86a\x10r\x83a\x14\x81V[\x85`@Q` \x01a\x10\x85\x93\x92\x91\x90a\x1C\xC4V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x10\xA1\x90a\x1C\\V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x10\xCD\x90a\x1C\\V[\x80\x15a\x11\x18W\x80`\x1F\x10a\x10\xEFWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x11\x18V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x10\xFBW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x15\xB2\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x116\x87\x84a\x1B\xF1V[\x81Q\x81\x10a\x11FWa\x11Fa\x1C\x04V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x10]V[P\x94\x93PPPPV[``a\x11n\x84\x84a\x1B\xF1V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x11\x86Wa\x11\x86a\x178V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x11\xAFW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x11YWa\x12\x82\x86a\x11\xC9\x83a\x14\x81V[\x85`@Q` \x01a\x11\xDC\x93\x92\x91\x90a\x1C\xC4V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x11\xF8\x90a\x1C\\V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x12$\x90a\x1C\\V[\x80\x15a\x12oW\x80`\x1F\x10a\x12FWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x12oV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x12RW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x16Q\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x12\x8D\x87\x84a\x1B\xF1V[\x81Q\x81\x10a\x12\x9DWa\x12\x9Da\x1C\x04V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x11\xB4V[`@Q\x7F|\x84\xC6\x9B\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c|\x84\xC6\x9B\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x13\x19W__\xFD[PZ\xFA\x15\x80\x15a\x13+W=__>=_\xFD[PPPPPPV[``a\x13?\x84\x84a\x1B\xF1V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x13WWa\x13Wa\x178V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x13\x80W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x11YWa\x14S\x86a\x13\x9A\x83a\x14\x81V[\x85`@Q` \x01a\x13\xAD\x93\x92\x91\x90a\x1C\xC4V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x13\xC9\x90a\x1C\\V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x13\xF5\x90a\x1C\\V[\x80\x15a\x14@W\x80`\x1F\x10a\x14\x17Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x14@V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x14#W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x16\xE4\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x14^\x87\x84a\x1B\xF1V[\x81Q\x81\x10a\x14nWa\x14na\x1C\x04V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x13\x85V[``\x81_\x03a\x14\xC3WPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x14\xECW\x80a\x14\xD6\x81a\x1DaV[\x91Pa\x14\xE5\x90P`\n\x83a\x1D\xC5V[\x91Pa\x14\xC6V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x15\x06Wa\x15\x06a\x178V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x150W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x02\xBAWa\x15E`\x01\x83a\x1B\xF1V[\x91Pa\x15R`\n\x86a\x1D\xD8V[a\x15]\x90`0a\x1D\xEBV[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x15rWa\x15ra\x1C\x04V[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x15\xAB`\n\x86a\x1D\xC5V[\x94Pa\x154V[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a\x16\x07\x90\x86\x90\x86\x90`\x04\x01a\x1D\xFEV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x16!W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x16H\x91\x90\x81\x01\x90a\x1E+V[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x16\xA5\x90\x86\x90\x86\x90`\x04\x01a\x1D\xFEV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x16\xC0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x16H\x91\x90a\x1C\xADV[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x16\xA5\x90\x86\x90\x86\x90`\x04\x01a\x1D\xFEV[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\x8EWa\x17\x8Ea\x178V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x17\xAFWa\x17\xAFa\x178V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x17\xCFW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17\xE5W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x17\xF5W__\xFD[\x805a\x18\x08a\x18\x03\x82a\x17\x96V[a\x17eV[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x18\x1CW__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x18\xC9W`?\x19\x87\x86\x03\x01\x84Ra\x18\xB4\x85\x83Qa\x18DV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x18\x98V[P\x92\x96\x95PPPPPPV[` \x81R_a\x16H` \x83\x01\x84a\x18DV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x194W\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\x19\0V[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x19\x8DW`\x1F\x19\x85\x84\x03\x01\x88Ra\x19w\x83\x83Qa\x18DV[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x19[V[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x18\xC9W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1A\x07`@\x87\x01\x82a\x19?V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x19\xBFV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x194W\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1A6V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x1A\xA6W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x1AfV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x18\xC9W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x1A\xFC`@\x88\x01\x82a\x18DV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x1B\x17\x81\x83a\x1ATV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1A\xD6V[` \x81R_a\x16H` \x83\x01\x84a\x19?V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x18\xC9W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1B\xAE`@\x87\x01\x82a\x1ATV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1BfV[\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\x16KWa\x16Ka\x1B\xC4V[\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x02\xBAa\x1CV\x83\x86a\x1C1V[\x84a\x1C1V[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1CpW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x1C\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x1C\xBDW__\xFD[PQ\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\x81R_a\x1C\xF5`\x01\x83\x01\x86a\x1C1V[\x7F[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x1D%`\x01\x82\x01\x86a\x1C1V[\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\x81Ra\x1DW`\x02\x82\x01\x85a\x1C1V[\x96\x95PPPPPPV[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x1D\x91Wa\x1D\x91a\x1B\xC4V[P`\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`\x12`\x04R`$_\xFD[_\x82a\x1D\xD3Wa\x1D\xD3a\x1D\x98V[P\x04\x90V[_\x82a\x1D\xE6Wa\x1D\xE6a\x1D\x98V[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a\x16KWa\x16Ka\x1B\xC4V[`@\x81R_a\x1E\x10`@\x83\x01\x85a\x18DV[\x82\x81\x03` \x84\x01Ra\x1E\"\x81\x85a\x18DV[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x1E;W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1EQW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x1EaW__\xFD[\x80Qa\x1Eoa\x18\x03\x82a\x17\x96V[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a\x1E\x83W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV\xFE\xA2dipfsX\"\x12 \xB1\x9D\x80\xD2\xFD&\x1F\x11oS\x91y\xAA\xD2\xEB*0\x95\x8E\xEC_\xBBf|\xA5y-$c\x1F\xE8\xFBdsolcC\0\x08\x1C\x003`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa);8\x03\x80a);\x839\x81\x01`@\x81\x90Ra\0.\x91a\x03+V[\x82\x82\x82\x82\x82\x82a\0?\x83Q`P\x14\x90V[a\0\x84W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x11`$\x82\x01RpBad genesis block`x\x1B`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\0\x8E\x84a\x01fV[\x90Pb\xFF\xFF\xFF\x82\x16\x15a\x01\tW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FPeriod start hash does not have `D\x82\x01R\x7Fwork. Hint: wrong byte order?\0\0\0`d\x82\x01R`\x84\x01a\0{V[_\x81\x81U`\x01\x82\x90U`\x02\x82\x90U\x81\x81R`\x04` R`@\x90 \x83\x90Ua\x012a\x07\xE0\x84a\x03\xFEV[a\x01<\x90\x84a\x04%V[_\x83\x81R`\x04` R`@\x90 Ua\x01S\x84a\x02&V[`\x05UPa\x05\xBD\x98PPPPPPPPPV[_`\x02\x80\x83`@Qa\x01x\x91\x90a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\x93W=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x04NV[`@Q` \x01a\x01\xC8\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x01\xE2\x91a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\xFDW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02 \x91\x90a\x04NV[\x92\x91PPV[_a\x02 a\x023\x83a\x028V[a\x02CV[_a\x02 \x82\x82a\x02SV[_a\x02 a\xFF\xFF`\xD0\x1B\x83a\x02\xF7V[_\x80a\x02ja\x02c\x84`Ha\x04eV[\x85\x90a\x03\tV[`\xE8\x1C\x90P_\x84a\x02|\x85`Ka\x04eV[\x81Q\x81\x10a\x02\x8CWa\x02\x8Ca\x04xV[\x01` \x01Q`\xF8\x1C\x90P_a\x02\xBE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x02\xD1`\x03\x84a\x04\x8CV[`\xFF\x16\x90Pa\x02\xE2\x81a\x01\0a\x05\x88V[a\x02\xEC\x90\x83a\x05\x93V[\x97\x96PPPPPPPV[_a\x03\x02\x82\x84a\x05\xAAV[\x93\x92PPPV[_a\x03\x02\x83\x83\x01` \x01Q\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x03=W__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03RW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03bW__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03{Wa\x03{a\x03\x17V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x03\xA9Wa\x03\xA9a\x03\x17V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x03\xC0W__\xFD[\x81` \x84\x01` \x83\x01^_` \x92\x82\x01\x83\x01R\x90\x86\x01Q`@\x90\x96\x01Q\x90\x97\x95\x96P\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x04\x0CWa\x04\x0Ca\x03\xEAV[P\x06\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x04^W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02 Wa\x02 a\x04\x11V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[`\x01\x81[`\x01\x84\x11\x15a\x04\xE0W\x80\x85\x04\x81\x11\x15a\x04\xC4Wa\x04\xC4a\x04\x11V[`\x01\x84\x16\x15a\x04\xD2W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x04\xA9V[\x93P\x93\x91PPV[_\x82a\x04\xF6WP`\x01a\x02 V[\x81a\x05\x02WP_a\x02 V[\x81`\x01\x81\x14a\x05\x18W`\x02\x81\x14a\x05\"Wa\x05>V[`\x01\x91PPa\x02 V[`\xFF\x84\x11\x15a\x053Wa\x053a\x04\x11V[PP`\x01\x82\x1Ba\x02 V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x05aWP\x81\x81\na\x02 V[a\x05m_\x19\x84\x84a\x04\xA5V[\x80_\x19\x04\x82\x11\x15a\x05\x80Wa\x05\x80a\x04\x11V[\x02\x93\x92PPPV[_a\x03\x02\x83\x83a\x04\xE8V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x02 Wa\x02 a\x04\x11V[_\x82a\x05\xB8Wa\x05\xB8a\x03\xEAV[P\x04\x90V[a#q\x80a\x05\xCA_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\xADW\x80c\xB9\x85b\x1A\x11a\0}W\x80c\xE3\xD8\xD8\xD8\x11a\0cW\x80c\xE3\xD8\xD8\xD8\x14a\x02\"W\x80c\xE4q\xE7,\x14a\x02)W\x80c\xF5\x8D\xB0o\x14a\x02=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x13\x91\x90a!WV[`@Q` \x01a\x0C%\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\x90\x82\x90Ra\x0C]\x91a!AV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0CxW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x07\x91\x90a!WV[_\x83\x85\x14\x80\x15a\x0C\xAAWP\x82\x85\x14[\x15a\x0C\xB7WP`\x01a\x04\xF1V[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x0C\xFFW\x89\x83\x14a\x0C\xDEW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x0C\xF7W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x0C\xBDV[P\x82\x84\x03a\r\x13W_\x94PPPPPa\x04\xF1V[\x80\x82\x14a\r&W_\x94PPPPPa\x04\xF1V[P`\x01\x98\x97PPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\rYW_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\r9V[P\x80a\x05\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x80\x82\x81[a\r\xB8`\x04`\x01a!\x9BV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0E\x0CW_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\r\xF1W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0E\x04V[a\r\xFB\x81\x84a!\xB7V[\x95\x94PPPPPV[`\x01\x01a\r\xACV[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_`P\x82Qa\x0B~\x91\x90a!.V[__a\x0Eo\x85a\x0B\xC3V[\x90P_a\x0E{\x82a\r\xA7V[\x90P_a\x0E\x87\x86a\x19\xE6V[\x90P\x84\x80a\x0E\x9CWP\x80a\x0E\x9A\x88a\x19\xE6V[\x14[a\x0F\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x03.V[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x12\x0EWa\x0F(`P\x82a!\xCAV[a\x0F3\x90`\x01a!\xB7V[a\x0F=\x90\x87a!\xB7V[\x93Pa\x0FK\x8A\x82`Pa\x19\xF1V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x11!W\x84a\x10\xA1\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x10\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x11\n`\x04\x85a!.V[_\x03a\x11!W_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x11,\x8B\x83a\x1A\x16V[\x14a\x11yW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[\x86a\x11\x84\x8B\x83a\x1A\xAFV[\x14a\x11\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x03.V[\x82\x96P`P\x81a\x12\x07\x91\x90a!\xB7V[\x90Pa\x0F\x15V[P\x81a\x12\x19\x8Ba\x0B\xC3V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x12\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x12\xD4\x84a\x0B\xC3V[\x90P_a\x12\xE0\x86a\x0B\xC3V[\x90P`\x01T\x81\x14a\x133W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x03.V[_\x82\x81R`\x03` R`@\x90 Ta\x13\x8DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x13\x9B\x87`\x01T\x84\x87a\x0C\x9BV[a\x14\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x03.V[\x81a\x14\x19\x88\x88\x88a\x17\x80V[\x14a\x14\x8CW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[`\x01\x82\x90U`\x02\x87\x90U_a\x14\xA0\x86a\x1A\xC7V[\x90P`\x05T\x81\x14a\x14\xB1W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x15\x01a\x14\xFC\x86a\x0B\xC3V[a\r\xA7V[\x90P_a\x15\x10a\x14\xFC\x86a\x0B\xC3V[\x90Pa\x15\x1Ea\x07\xE0\x82a!.V[a\x07\xDF\x14a\x15\x94W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x03.V[a\x15\xA0\x82a\x07\xDFa!\xB7V[\x81\x14a\x16\x14W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x03.V[a\x16\x1D\x85a\x1A\xC7V[a\x16&\x87a\x1A\xC7V[\x14a\x16\x99W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x03.V[_a\x16\xA3\x85a\x19\xE6V[\x90P_a\x16\xD5a\x16\xB2\x89a\x19\xE6V[a\x16\xBB\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x16\xCA\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x1B\x0CV[\x90P\x81\x81\x83\x16\x14a\x17(W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_a\x172\x89a\x1A\xC7V[\x90P\x80`\x06T\x14\x15\x80\x15a\x17\\WPa\x07\xE0a\x17O`\x01Ta\r\xA7V[a\x17Y\x91\x90a!\xDDV[\x84\x11[\x15a\x17gW`\x06\x81\x90U[a\x17s\x88\x88`\x01a\x0EdV[\x99\x98PPPPPPPPPV[__a\x17\x8B\x85a\r\xA7V[\x90P_a\x17\x9Aa\x14\xFC\x86a\x0B\xC3V[\x90P_a\x17\xA9a\x14\xFC\x86a\x0B\xC3V[\x90P\x82\x82\x10\x15\x80\x15a\x17\xBBWP\x82\x81\x10\x15[a\x18-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x18:a\x07\xE0\x85a!.V[a\x18F\x85a\x07\xE0a!\xB7V[a\x18P\x91\x90a!\xDDV[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x18bWP\x80[\x15a\x18}Wa\x18p\x89a\x0B\xC3V[\x96PPPPPPPa\n\xA3V[\x81\x80\x15a\x18\x88WP\x80\x15[\x15a\x18\x96Wa\x18p\x88a\x0B\xC3V[\x81\x80\x15a\x18\xA0WP\x80[\x15a\x18\xC4W\x83\x85\x10\x15a\x18\xBBWa\x18\xB6\x88a\x0B\xC3V[a\x18pV[a\x18p\x89a\x0B\xC3V[a\x18\xCD\x88a\x1A\xC7V[a\x18\xD9a\x07\xE0\x86a!.V[a\x18\xE3\x91\x90a!\xF0V[a\x18\xEC\x8Aa\x1A\xC7V[a\x18\xF8a\x07\xE0\x88a!.V[a\x19\x02\x91\x90a!\xF0V[\x10\x15a\x18\xBBWa\x18p\x88a\x0B\xC3V[`\x07T_\x90`\xFF\x16\x15a\x19/WP`\x07Ta\x01\0\x90\x04`\xFF\x16a\n\xA3V[a\x19:\x84\x84\x84a\x1B\x94V[\x90Pa\n\xA3V[_` \x84Qa\x19P\x91\x90a!.V[\x15a\x19\\WP_a\x04\xF1V[\x83Q_\x03a\x19kWP_a\x04\xF1V[\x81\x85_[\x86Q\x81\x10\x15a\x19\xD9Wa\x19\x83`\x02\x84a!.V[`\x01\x03a\x19\xA7Wa\x19\xA0a\x19\x9A\x88\x83\x01` \x01Q\x90V[\x83a\x1B\xD5V[\x91Pa\x19\xC0V[a\x19\xBD\x82a\x19\xB8\x89\x84\x01` \x01Q\x90V[a\x1B\xD5V[\x91P[`\x01\x92\x90\x92\x1C\x91a\x19\xD2` \x82a!\xB7V[\x90Pa\x19oV[P\x90\x93\x14\x95\x94PPPPPV[_a\x05\x07\x82_a\x1A\x16V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x1A-a\x1A&\x84`Ha!\xB7V[\x85\x90a\x1B\xE0V[`\xE8\x1C\x90P_\x84a\x1A?\x85`Ka!\xB7V[\x81Q\x81\x10a\x1AOWa\x1AOa\"\x07V[\x01` \x01Q`\xF8\x1C\x90P_a\x1A\x81\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1A\x94`\x03\x84a\"4V[`\xFF\x16\x90Pa\x1A\xA5\x81a\x01\0a#0V[a\x08-\x90\x83a!\xF0V[_a\x05\x04a\x1A\xBE\x83`\x04a!\xB7V[\x84\x01` \x01Q\x90V[_a\x05\x07a\x1A\xD4\x83a\x19\xE6V[a\x1B\xEEV[_a\x05\x07a\x1A\xE6\x83a\x1C\x15V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1B\x18\x83\x85a\x1C!V[\x90Pa\x1B(b\x12u\0`\x04a\x1C|V[\x81\x10\x15a\x1B@Wa\x1B=b\x12u\0`\x04a\x1C|V[\x90P[a\x1BNb\x12u\0`\x04a\x1C\x87V[\x81\x11\x15a\x1BfWa\x1Bcb\x12u\0`\x04a\x1C\x87V[\x90P[_a\x1B~\x82a\x1Bx\x88b\x01\0\0a\x1C|V[\x90a\x1C\x87V[\x90Pa\n\x8Ab\x01\0\0a\x1Bx\x83b\x12u\0a\x1C|V[_\x82\x81[\x83\x81\x10\x15a\x1B\xCAW\x85\x82\x03a\x1B\xB2W`\x01\x92PPPa\n\xA3V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x1B\x98V[P_\x95\x94PPPPPV[_a\x05\x04\x83\x83a\x1C\xFAV[_a\x05\x04\x83\x83\x01` \x01Q\x90V[_a\x05\x07{\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\x83a\x1C|V[_a\x05\x07\x82`Da\x1B\xE0V[_\x82\x82\x11\x15a\x1CrW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x05\x04\x82\x84a!\xDDV[_a\x05\x04\x82\x84a!\xCAV[_\x82_\x03a\x1C\x96WP_a\x05\x07V[a\x1C\xA0\x82\x84a!\xF0V[\x90P\x81a\x1C\xAD\x84\x83a!\xCAV[\x14a\x05\x07W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x03.V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1D1W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DHW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1D_W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1DvW__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1D\x91W__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xA7W__\xFD[a\x1D\xB3\x8A\x82\x8B\x01a\x1D!V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xD2W__\xFD[a\x1D\xDE\x8A\x82\x8B\x01a\x1D!V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1D\xFE`\x80\x89\x01a\x1DfV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[____`\x80\x85\x87\x03\x12\x15a\x1E\x1FW__\xFD[PP\x825\x94` \x84\x015\x94P`@\x84\x015\x93``\x015\x92P\x90PV[__`@\x83\x85\x03\x12\x15a\x1ELW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1EkW__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1E\x85W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x9BW__\xFD[a\x1E\xA7\x87\x82\x88\x01a\x1D!V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\xC6W__\xFD[a\x1E\xD2\x87\x82\x88\x01a\x1D!V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1E\xF3W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x10W__\xFD[a\x1F\x1C\x89\x82\x8A\x01a\x1D!V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F;W__\xFD[a\x1FG\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1FtW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x8AW__\xFD[a\x1F\x96\x89\x82\x8A\x01a\x1D!V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xB5W__\xFD[a\x1F\xC1\x89\x82\x8A\x01a\x1D!V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xE0W__\xFD[a\x1F\xEC\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_____``\x86\x88\x03\x12\x15a \x12W__\xFD[\x855\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a /W__\xFD[a ;\x88\x82\x89\x01a\x1D!V[\x90\x95P\x93PP`@\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a ZW__\xFD[a f\x88\x82\x89\x01a\x1D!V[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[___``\x84\x86\x03\x12\x15a \x89W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a \xB1W__\xFD[\x825\x91Pa \xC1` \x84\x01a\x1DfV[\x90P\x92P\x92\x90PV[\x805\x80\x15\x15\x81\x14a\x1DvW__\xFD[__`@\x83\x85\x03\x12\x15a \xEAW__\xFD[a \xF3\x83a \xCAV[\x91Pa \xC1` \x84\x01a \xCAV[\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!^<#\x14a\x01*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x0FTV[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\0W\x83\x82\x90_R` _ \x01\x80Ta\x03u\x90a\x15\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xA1\x90a\x15\xECV[\x80\x15a\x03\xECW\x80`\x1F\x10a\x03\xC3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xECV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xCFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03XV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xFAV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x05I\x90a\x15\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05u\x90a\x15\xECV[\x80\x15a\x05\xC0W\x80`\x1F\x10a\x05\x97Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05\xC0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05\xA3W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06WW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x06\x04W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05\x19V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\x06\xAF\x90a\x15\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06\xDB\x90a\x15\xECV[\x80\x15a\x07&W\x80`\x1F\x10a\x06\xFDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07&V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\tW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x06\x92V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x08%W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x07\xD2W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07]V[_s*\xC9\x8D\xB4\x1C\xBD1r\xCB{\x8F\xD8\xA8\xAB;\x91\xCF\xE4]\xCF\x90P_\x81`@Qa\x08c\x90a\x12-V[s\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_\xF0\x80\x15\x80\x15a\x08\x99W=__>=_\xFD[P\x90P_r\xB6~H\x05\x13\x83%\xCE\x87\x1D^'\xDC\x15\xF9\x94h\x1B\xC1sc\x1A\xE9~$\xF9\xF3\x01P\xD3\x1D\x95\x8D7\x91Yu\xF1.\xD8`@Qa\x08\xD2\x90a\x12:V[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\t\x0FW=__>=_\xFD[P\x90P_\x82\x82`@Qa\t!\x90a\x12GV[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\t^W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t\xD8W__\xFD[PZ\xF1\x15\x80\x15a\t\xEAW=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\nmW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\x91\x91\x90a\x16=V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0B%W__\xFD[PZ\xF1\x15\x80\x15a\x0B7W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0B\x94W__\xFD[PZ\xF1\x15\x80\x15a\x0B\xA6W=__>=_\xFD[PP`@Q\x7Ft\xD1E\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\x81R`\x01`\x04\x82\x01Ra\x0CE\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x91Pct\xD1E\xB7\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0C\x17W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C;\x91\x90a\x16cV[c\x05\xF5\xE1\0a\x11\xAAV[PPPPV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r6W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C\xE3W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0CnV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\r\x8E\x90a\x15\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\xBA\x90a\x15\xECV[\x80\x15a\x0E\x05W\x80`\x1F\x10a\r\xDCWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0E\x05V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r\xE8W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\rqV[`\x08T_\x90`\xFF\x16\x15a\x0E0WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\xBEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\xE2\x91\x90a\x16cV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\xEFW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x10\x16\x91\x90\x81\x01\x90a\x16\xA7V[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x104\x92\x91\x90a\x17[V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10PW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10t\x91\x90a\x16cV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10\xEDW__\xFD[PZ\xF1\x15\x80\x15a\x10\xFFW=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11\x7FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\xA3\x91\x90a\x16=V[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x12\x13W__\xFD[PZ\xFA\x15\x80\x15a\x12%W=__>=_\xFD[PPPPPPV[a\x0C\xD4\x80a\x17}\x839\x01\x90V[a\x0C\xF5\x80a$Q\x839\x01\x90V[a\r\x8C\x80a1F\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x12\xA1W\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\x12mV[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\xC2W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x13\xA8W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x13\x92\x84\x86Qa\x12\xACV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x13XV[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x13\0V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x14 W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x13\xE0V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\xC2W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x14v`@\x88\x01\x82a\x12\xACV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x14\x91\x81\x83a\x13\xCEV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14PV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\xC2W`?\x19\x87\x86\x03\x01\x84Ra\x14\xEA\x85\x83Qa\x12\xACV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\xCEV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\xC2W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x15m`@\x87\x01\x82a\x13\xCEV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15%V[\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\x15\xA6W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x15\xBEW__\xFD[\x845\x93Pa\x15\xCE` \x86\x01a\x15\x83V[\x92Pa\x15\xDC`@\x86\x01a\x15\x83V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x16\0W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x167W\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x16MW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x16\\W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x16sW__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x16\xB7W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\xCDW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x16\xDDW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\xF7Wa\x16\xF7a\x16zV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x17'Wa\x17'a\x16zV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x17>W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x17m`@\x83\x01\x85a\x12\xACV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xA0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x0C\xD48\x03\x80a\x0C\xD4\x839\x81\x01`@\x81\x90Ra\0.\x91a\0?V[`\x01`\x01`\xA0\x1B\x03\x16`\x80Ra\0lV[_` \x82\x84\x03\x12\x15a\0OW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0eW__\xFD[\x93\x92PPPV[`\x80Qa\x0C=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02UW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02y\x91\x90a\x0B,V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xE6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\n\x91\x90a\x0BGV[\x83Q\x90\x91P\x81\x10\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\x9Es\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x85\x83a\x05\xB4V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xB3\x90\x85\x90\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\x90`\x84\x01[`@\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\x0FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05-W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05Q\x91\x90a\x0BGV[a\x05[\x91\x90a\x0B^V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xB3\x90\x85\x90\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\x90`d\x01a\x04OV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x06\n\x90\x84\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\x90`d\x01a\x04OV[PPPV[_a\x06p\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\x07\x1A\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\nW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x8E\x91\x90a\x0B\x9CV[a\x06\nW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[``a\x07(\x84\x84_\x85a\x072V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xC4W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08BW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[__\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\x08j\x91\x90a\x0B\xBBV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xA4W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xA9V[``\x91P[P\x91P\x91Pa\x08\xB9\x82\x82\x86a\x08\xC4V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xD3WP\x81a\x07+V[\x82Q\x15a\x08\xE3W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03t\x91\x90a\x0B\xD1V[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\t8W__\xFD[PV[\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\x8BWa\t\x8Ba\t;V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xBAWa\t\xBAa\t;V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xD5W__\xFD[\x845a\t\xE0\x81a\t\x17V[\x93P` \x85\x015\x92P`@\x85\x015a\t\xF7\x81a\t\x17V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x12W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\"W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nz9,\xA4\xD4K\x0C\x1B\x8D\x91\x90a\x0B\x0BV[\x90Pa\x01L\x85\x85\x85\x84a\x023V[PPPPPV[`@Q\x7Fz~\r\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\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\x7F\0\0\0\0\0\0\0\0\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`$\x83\x01R_\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\x90\x91\x16\x90cz~\r\x92\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\tW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02-\x91\x90a\x0B/V[\x92\x91PPV[a\x02Us\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x043V[a\x02\x96s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\xF7V[`@Q\x7F\xE4hB\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\x83\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\x81\x16`$\x83\x01R\x85\x81\x16`D\x83\x01R`d\x82\x01\x85\x90R_\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\x90\x91\x16\x90c\xE4hB\xB7\x90`\x84\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\\W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x80\x91\x90a\x0B/V[\x82Q\x90\x91P\x81\x10\x15a\x03\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q_\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xF1\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xF2V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05kW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x8F\x91\x90a\x0B/V[a\x05\x99\x91\x90a\x0BFV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xF1\x90\x85\x90\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\x90`d\x01a\x04\x8DV[_a\x06S\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\x07\x02\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\xFDW\x80\x80` \x01\x90Q\x81\x01\x90a\x06q\x91\x90a\x0B~V[a\x06\xFDW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[PPPV[``a\x07\x10\x84\x84_\x85a\x07\x1AV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xACW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08*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\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x03\xEAV[__\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\x08R\x91\x90a\x0B\x9DV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x8CW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x91V[``\x91P[P\x91P\x91Pa\x08\xA1\x82\x82\x86a\x08\xACV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xBBWP\x81a\x07\x13V[\x82Q\x15a\x08\xCBW\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\xEA\x91\x90a\x0B\xB3V[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\t W__\xFD[PV[\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\tsWa\tsa\t#V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xA2Wa\t\xA2a\t#V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xBDW__\xFD[\x845a\t\xC8\x81a\x08\xFFV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xDF\x81a\x08\xFFV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xFAW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\nW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n$Wa\n$a\t#V[a\n7` `\x1F\x19`\x1F\x84\x01\x16\x01a\tyV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nKW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[_` \x82\x84\x03\x12\x15a\n|W__\xFD[\x815a\x07\x13\x81a\x08\xFFV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x9BW__\xFD[\x855a\n\xA6\x81a\x08\xFFV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xBD\x81a\x08\xFFV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xEEW__\xFD[Pa\n\xF7a\tPV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x1CW__\xFD[Pa\x0B%a\tPV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B?W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02-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[_` \x82\x84\x03\x12\x15a\x0B\x8EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x13W__\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\xFE\xA2dipfsX\"\x12 1\xA9_\tS$\x80\xC4eD\\\xF1\xA5F\x84\x08w?\xBD\x88\xEC\xC5\xCAl\x9C\xCA\x82\xDE\xCAb4\x08dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\x8C8\x03\x80a\r\x8C\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\xB6a\0\xD6_9_\x81\x81`\xCB\x01R\x81\x81a\x03\xE1\x01Ra\x04a\x01R_\x81\x81`S\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0C\xB6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c#\x17\x10\xA5\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xA6\xAA\x9C\xC0\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\n=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFB\xFAw\xCF`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B\xA6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x0EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x032\x91\x90a\x0B\xA6V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xC3\x91\x90a\x0B\xC1V[\x90Pa\x04\x06s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x84V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xA2W__\xFD[PZ\xF1\x15\x80\x15a\x04\xB4W=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05~\x90\x85\x90\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\x90`\x84\x01[`@\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\x7FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1C\x91\x90a\x0B\xC1V[a\x06&\x91\x90a\x0B\xD8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05~\x90\x85\x90\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\x90`d\x01a\x05\x1AV[_a\x06\xE0\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\x07\x94\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\x8FW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFE\x91\x90a\x0C\x16V[a\x07\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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x07\xA2\x84\x84_\x85a\x07\xACV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08>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\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\x07\x86V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\xBCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x86V[__\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\x08\xE4\x91\x90a\x0C5V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\t\x1EW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t#V[``\x91P[P\x91P\x91Pa\t3\x82\x82\x86a\t>V[\x97\x96PPPPPPPV[``\x83\x15a\tMWP\x81a\x07\xA5V[\x82Q\x15a\t]W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x86\x91\x90a\x0CKV[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\t\xB2W__\xFD[PV[\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\n\x05Wa\n\x05a\t\xB5V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n4Wa\n4a\t\xB5V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\nOW__\xFD[\x845a\nZ\x81a\t\x91V[\x93P` \x85\x015\x92P`@\x85\x015a\nq\x81a\t\x91V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x8CW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x9CW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xB6Wa\n\xB6a\t\xB5V[a\n\xC9` `\x1F\x19`\x1F\x84\x01\x16\x01a\n\x0BV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n\xDDW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0B\x12W__\xFD[\x855a\x0B\x1D\x81a\t\x91V[\x94P` \x86\x015\x93P`@\x86\x015a\x0B4\x81a\t\x91V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0BeW__\xFD[Pa\x0Bna\t\xE2V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x93W__\xFD[Pa\x0B\x9Ca\t\xE2V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xB6W__\xFD[\x81Qa\x07\xA5\x81a\t\x91V[_` \x82\x84\x03\x12\x15a\x0B\xD1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0C\x10W\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[_` \x82\x84\x03\x12\x15a\x0C&W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\xA5W__\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\xFE\xA2dipfsX\"\x12 #\xC6\x9F\x1F4j\x13~\xBA\xBD\x05\x83\xE0\xB1\x05\x8FN\xC6a;\x1Cg\xB1 >\x01O\x1B\xB3\x9BCgdsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 \x80\xC4k\xF0\xC6\x19\xCE\x07~;\x88Z\xE8M\x89\xB5F\xF0\xE2X\xB6\xE6\xE0\x88\xE6\xEB\xD68b&\x90\x9CdsolcC\0\x08\x1C\x003", ); /// 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\x01/W_5`\xE0\x1C\x80c\x85\"l\x81\x11a\0\xADW\x80c\xB5P\x8A\xA9\x11a\0}W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x02OW\x80c\xFAv&\xD4\x14a\x02WW\x80c\xFA\xD0k\x8F\x14a\x02dW__\xFD[\x80c\xB5P\x8A\xA9\x14a\x02/W\x80c\xBAAO\xA6\x14a\x027W__\xFD[\x80c\x85\"l\x81\x14a\x01\xF5W\x80c\x91j\x17\xC6\x14a\x02\nW\x80c\x91\xAE\x19\xCA\x14a\x02\x1FW\x80c\xB0FO\xDC\x14a\x02'W__\xFD[\x80c>^<#\x11a\x01\x02W\x80cD\xBA\xDB\xB6\x11a\0\xE8W\x80cD\xBA\xDB\xB6\x14a\x01\xB6W\x80cFCe\x8E\x14a\x01\xD6W\x80cf\xD9\xA9\xA0\x14a\x01\xE0W__\xFD[\x80c>^<#\x14a\x01\xA6W\x80c?r\x86\xF4\x14a\x01\xAEW__\xFD[\x80c\x08\x13\x85*\x14a\x013W\x80c\x1C\r\xA8\x1F\x14a\x01\\W\x80c\x1E\xD7\x83\x1C\x14a\x01|W\x80c*\xDE8\x80\x14a\x01\x91W[__\xFD[a\x01Fa\x01A6`\x04a\x17\xBDV[a\x02wV[`@Qa\x01S\x91\x90a\x18rV[`@Q\x80\x91\x03\x90\xF3[a\x01oa\x01j6`\x04a\x17\xBDV[a\x02\xC2V[`@Qa\x01S\x91\x90a\x18\xD5V[a\x01\x84a\x034V[`@Qa\x01S\x91\x90a\x18\xE7V[a\x01\x99a\x03\xA1V[`@Qa\x01S\x91\x90a\x19\x99V[a\x01\x84a\x04\xEAV[a\x01\x84a\x05UV[a\x01\xC9a\x01\xC46`\x04a\x17\xBDV[a\x05\xC0V[`@Qa\x01S\x91\x90a\x1A\x1DV[a\x01\xDEa\x06\x03V[\0[a\x01\xE8a\x07OV[`@Qa\x01S\x91\x90a\x1A\xB0V[a\x01\xFDa\x08\xC8V[`@Qa\x01S\x91\x90a\x1B.V[a\x02\x12a\t\x93V[`@Qa\x01S\x91\x90a\x1B@V[a\x01\xDEa\n\x96V[a\x02\x12a\x0C\xB5V[a\x01\xFDa\r\xB8V[a\x02?a\x0E\x83V[`@Q\x90\x15\x15\x81R` \x01a\x01SV[a\x01\x84a\x0FSV[`\x1FTa\x02?\x90`\xFF\x16\x81V[a\x01\xC9a\x02r6`\x04a\x17\xBDV[a\x0F\xBEV[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x10\x01V[\x94\x93PPPPV[``_a\x02\xD0\x85\x85\x85a\x02wV[\x90P_[a\x02\xDE\x85\x85a\x1B\xF1V[\x81\x10\x15a\x03+W\x82\x82\x82\x81Q\x81\x10a\x02\xF8Wa\x02\xF8a\x1C\x04V[` \x02` \x01\x01Q`@Q` \x01a\x03\x11\x92\x91\x90a\x1CHV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x02\xD4V[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\xCAW\x83\x82\x90_R` _ \x01\x80Ta\x04?\x90a\x1C\\V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x04k\x90a\x1C\\V[\x80\x15a\x04\xB6W\x80`\x1F\x10a\x04\x8DWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x04\xB6V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x04\x99W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x04\"V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x03\xC4V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x11bV[`@\x80Q\x80\x82\x01\x82R`\x10\x81R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x06\x84\x91\x90`\x04\x01a\x18\xD5V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x06\x9BW__\xFD[PZ\xF1\x15\x80\x15a\x06\xADW=__>=_\xFD[PP`\x1FT`@Q\x7F0\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\x82\x01R`\x03`$\x82\x01Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x92Pc0\x01{;\x91P`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07(W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07L\x91\x90a\x1C\xADV[PV[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x07\xA2\x90a\x1C\\V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07\xCE\x90a\x1C\\V[\x80\x15a\x08\x19W\x80`\x1F\x10a\x07\xF0Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x08\x19V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\xFCW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x08\xB0W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x08]W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07rV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x01\x80Ta\t\x08\x90a\x1C\\V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\t4\x90a\x1C\\V[\x80\x15a\t\x7FW\x80`\x1F\x10a\tVWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\t\x7FV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\tbW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x08\xEBV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\n~W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\n+W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\t\xB6V[_a\n\xD8`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01\x7Fchain\0\0\0\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_`\x06a\x05\xC0V[\x90P_[`\x06\x81\x10\x15a\x0C\xB1Wa\x0B\xC5`\x1F`\x01\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\x16c0\x01{;\x84\x84\x81Q\x81\x10a\x0B8Wa\x0B8a\x1C\x04V[` \x02` \x01\x01Q_`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0Bg\x92\x91\x90\x91\x82R` \x82\x01R`@\x01\x90V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0B\x82W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\xA6\x91\x90a\x1C\xADV[\x83\x83\x81Q\x81\x10a\x0B\xB8Wa\x0B\xB8a\x1C\x04V[` \x02` \x01\x01Qa\x12\xB0V[\x80\x15a\x0C\xA9Wa\x0C\xA9`\x1F`\x01\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\x16c0\x01{;\x84\x84\x81Q\x81\x10a\x0C\x1EWa\x0C\x1Ea\x1C\x04V[` \x02` \x01\x01Q`\x01`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0CN\x92\x91\x90\x91\x82R` \x82\x01R`@\x01\x90V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0CiW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x8D\x91\x90a\x1C\xADV[\x83a\x0C\x99`\x01\x85a\x1B\xF1V[\x81Q\x81\x10a\x0B\xB8Wa\x0B\xB8a\x1C\x04V[`\x01\x01a\n\xDCV[PPV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\xA0W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\rMW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xD8V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\xE1W\x83\x82\x90_R` _ \x01\x80Ta\r\xF8\x90a\x1C\\V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0E$\x90a\x1C\\V[\x80\x15a\x0EoW\x80`\x1F\x10a\x0EFWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0EoV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0ERW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\r\xDBV[`\x08T_\x90`\xFF\x16\x15a\x0E\x9AWP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F(W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0FL\x91\x90a\x1C\xADV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03\x97W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03lWPPPPP\x90P\x90V[``a\x02\xBA\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x133V[``a\x10\r\x84\x84a\x1B\xF1V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10%Wa\x10%a\x178V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x10XW\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x10CW\x90P[P\x90P\x83[\x83\x81\x10\x15a\x11YWa\x11+\x86a\x10r\x83a\x14\x81V[\x85`@Q` \x01a\x10\x85\x93\x92\x91\x90a\x1C\xC4V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x10\xA1\x90a\x1C\\V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x10\xCD\x90a\x1C\\V[\x80\x15a\x11\x18W\x80`\x1F\x10a\x10\xEFWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x11\x18V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x10\xFBW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x15\xB2\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x116\x87\x84a\x1B\xF1V[\x81Q\x81\x10a\x11FWa\x11Fa\x1C\x04V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x10]V[P\x94\x93PPPPV[``a\x11n\x84\x84a\x1B\xF1V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x11\x86Wa\x11\x86a\x178V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x11\xAFW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x11YWa\x12\x82\x86a\x11\xC9\x83a\x14\x81V[\x85`@Q` \x01a\x11\xDC\x93\x92\x91\x90a\x1C\xC4V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x11\xF8\x90a\x1C\\V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x12$\x90a\x1C\\V[\x80\x15a\x12oW\x80`\x1F\x10a\x12FWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x12oV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x12RW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x16Q\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x12\x8D\x87\x84a\x1B\xF1V[\x81Q\x81\x10a\x12\x9DWa\x12\x9Da\x1C\x04V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x11\xB4V[`@Q\x7F|\x84\xC6\x9B\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c|\x84\xC6\x9B\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x13\x19W__\xFD[PZ\xFA\x15\x80\x15a\x13+W=__>=_\xFD[PPPPPPV[``a\x13?\x84\x84a\x1B\xF1V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x13WWa\x13Wa\x178V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x13\x80W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x11YWa\x14S\x86a\x13\x9A\x83a\x14\x81V[\x85`@Q` \x01a\x13\xAD\x93\x92\x91\x90a\x1C\xC4V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x13\xC9\x90a\x1C\\V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x13\xF5\x90a\x1C\\V[\x80\x15a\x14@W\x80`\x1F\x10a\x14\x17Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x14@V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x14#W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x16\xE4\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x14^\x87\x84a\x1B\xF1V[\x81Q\x81\x10a\x14nWa\x14na\x1C\x04V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x13\x85V[``\x81_\x03a\x14\xC3WPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x14\xECW\x80a\x14\xD6\x81a\x1DaV[\x91Pa\x14\xE5\x90P`\n\x83a\x1D\xC5V[\x91Pa\x14\xC6V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x15\x06Wa\x15\x06a\x178V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x150W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x02\xBAWa\x15E`\x01\x83a\x1B\xF1V[\x91Pa\x15R`\n\x86a\x1D\xD8V[a\x15]\x90`0a\x1D\xEBV[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x15rWa\x15ra\x1C\x04V[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x15\xAB`\n\x86a\x1D\xC5V[\x94Pa\x154V[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a\x16\x07\x90\x86\x90\x86\x90`\x04\x01a\x1D\xFEV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x16!W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x16H\x91\x90\x81\x01\x90a\x1E+V[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x16\xA5\x90\x86\x90\x86\x90`\x04\x01a\x1D\xFEV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x16\xC0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x16H\x91\x90a\x1C\xADV[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x16\xA5\x90\x86\x90\x86\x90`\x04\x01a\x1D\xFEV[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x17\x8EWa\x17\x8Ea\x178V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x17\xAFWa\x17\xAFa\x178V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x17\xCFW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17\xE5W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x17\xF5W__\xFD[\x805a\x18\x08a\x18\x03\x82a\x17\x96V[a\x17eV[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x18\x1CW__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x18\xC9W`?\x19\x87\x86\x03\x01\x84Ra\x18\xB4\x85\x83Qa\x18DV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x18\x98V[P\x92\x96\x95PPPPPPV[` \x81R_a\x16H` \x83\x01\x84a\x18DV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x194W\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\x19\0V[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x19\x8DW`\x1F\x19\x85\x84\x03\x01\x88Ra\x19w\x83\x83Qa\x18DV[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x19[V[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x18\xC9W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1A\x07`@\x87\x01\x82a\x19?V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x19\xBFV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x194W\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1A6V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x1A\xA6W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x1AfV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x18\xC9W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x1A\xFC`@\x88\x01\x82a\x18DV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x1B\x17\x81\x83a\x1ATV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1A\xD6V[` \x81R_a\x16H` \x83\x01\x84a\x19?V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x18\xC9W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1B\xAE`@\x87\x01\x82a\x1ATV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1BfV[\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\x16KWa\x16Ka\x1B\xC4V[\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x02\xBAa\x1CV\x83\x86a\x1C1V[\x84a\x1C1V[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x1CpW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x1C\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x1C\xBDW__\xFD[PQ\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\x81R_a\x1C\xF5`\x01\x83\x01\x86a\x1C1V[\x7F[\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x1D%`\x01\x82\x01\x86a\x1C1V[\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\x81Ra\x1DW`\x02\x82\x01\x85a\x1C1V[\x96\x95PPPPPPV[_\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x1D\x91Wa\x1D\x91a\x1B\xC4V[P`\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`\x12`\x04R`$_\xFD[_\x82a\x1D\xD3Wa\x1D\xD3a\x1D\x98V[P\x04\x90V[_\x82a\x1D\xE6Wa\x1D\xE6a\x1D\x98V[P\x06\x90V[\x80\x82\x01\x80\x82\x11\x15a\x16KWa\x16Ka\x1B\xC4V[`@\x81R_a\x1E\x10`@\x83\x01\x85a\x18DV[\x82\x81\x03` \x84\x01Ra\x1E\"\x81\x85a\x18DV[\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x1E;W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1EQW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x1EaW__\xFD[\x80Qa\x1Eoa\x18\x03\x82a\x17\x96V[\x81\x81R\x85` \x83\x85\x01\x01\x11\x15a\x1E\x83W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV\xFE\xA2dipfsX\"\x12 \xB1\x9D\x80\xD2\xFD&\x1F\x11oS\x91y\xAA\xD2\xEB*0\x95\x8E\xEC_\xBBf|\xA5y-$c\x1F\xE8\xFBdsolcC\0\x08\x1C\x003", + b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xFBW_5`\xE0\x1C\x80c\x95\x90&i\x11a\0\x93W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x01\xBBW\x80c\xF9\xCE\x0EZ\x14a\x01\xC3W\x80c\xFAv&\xD4\x14a\x01\xD6W\x80c\xFC\x0CTj\x14a\x01\xE3W__\xFD[\x80c\x95\x90&i\x14a\x01\x8BW\x80c\xB0FO\xDC\x14a\x01\x93W\x80c\xB5P\x8A\xA9\x14a\x01\x9BW\x80c\xBAAO\xA6\x14a\x01\xA3W__\xFD[\x80c?r\x86\xF4\x11a\0\xCEW\x80c?r\x86\xF4\x14a\x01DW\x80cf\xD9\xA9\xA0\x14a\x01LW\x80c\x85\"l\x81\x14a\x01aW\x80c\x91j\x17\xC6\x14a\x01vW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x1E\xD7\x83\x1C\x14a\x01\tW\x80c*\xDE8\x80\x14a\x01'W\x80c>^<#\x14a\x01*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x0FTV[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\0W\x83\x82\x90_R` _ \x01\x80Ta\x03u\x90a\x15\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xA1\x90a\x15\xECV[\x80\x15a\x03\xECW\x80`\x1F\x10a\x03\xC3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xECV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xCFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03XV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xFAV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x05I\x90a\x15\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05u\x90a\x15\xECV[\x80\x15a\x05\xC0W\x80`\x1F\x10a\x05\x97Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05\xC0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05\xA3W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06WW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x06\x04W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05\x19V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\x06\xAF\x90a\x15\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06\xDB\x90a\x15\xECV[\x80\x15a\x07&W\x80`\x1F\x10a\x06\xFDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07&V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\tW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x06\x92V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x08%W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x07\xD2W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07]V[_s*\xC9\x8D\xB4\x1C\xBD1r\xCB{\x8F\xD8\xA8\xAB;\x91\xCF\xE4]\xCF\x90P_\x81`@Qa\x08c\x90a\x12-V[s\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_\xF0\x80\x15\x80\x15a\x08\x99W=__>=_\xFD[P\x90P_r\xB6~H\x05\x13\x83%\xCE\x87\x1D^'\xDC\x15\xF9\x94h\x1B\xC1sc\x1A\xE9~$\xF9\xF3\x01P\xD3\x1D\x95\x8D7\x91Yu\xF1.\xD8`@Qa\x08\xD2\x90a\x12:V[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\t\x0FW=__>=_\xFD[P\x90P_\x82\x82`@Qa\t!\x90a\x12GV[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\t^W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t\xD8W__\xFD[PZ\xF1\x15\x80\x15a\t\xEAW=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\nmW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\x91\x91\x90a\x16=V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0B%W__\xFD[PZ\xF1\x15\x80\x15a\x0B7W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0B\x94W__\xFD[PZ\xF1\x15\x80\x15a\x0B\xA6W=__>=_\xFD[PP`@Q\x7Ft\xD1E\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\x81R`\x01`\x04\x82\x01Ra\x0CE\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x91Pct\xD1E\xB7\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0C\x17W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C;\x91\x90a\x16cV[c\x05\xF5\xE1\0a\x11\xAAV[PPPPV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r6W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C\xE3W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0CnV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\r\x8E\x90a\x15\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\xBA\x90a\x15\xECV[\x80\x15a\x0E\x05W\x80`\x1F\x10a\r\xDCWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0E\x05V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r\xE8W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\rqV[`\x08T_\x90`\xFF\x16\x15a\x0E0WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\xBEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\xE2\x91\x90a\x16cV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\xEFW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x10\x16\x91\x90\x81\x01\x90a\x16\xA7V[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x104\x92\x91\x90a\x17[V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10PW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10t\x91\x90a\x16cV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10\xEDW__\xFD[PZ\xF1\x15\x80\x15a\x10\xFFW=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11\x7FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\xA3\x91\x90a\x16=V[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x12\x13W__\xFD[PZ\xFA\x15\x80\x15a\x12%W=__>=_\xFD[PPPPPPV[a\x0C\xD4\x80a\x17}\x839\x01\x90V[a\x0C\xF5\x80a$Q\x839\x01\x90V[a\r\x8C\x80a1F\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x12\xA1W\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\x12mV[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\xC2W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x13\xA8W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x13\x92\x84\x86Qa\x12\xACV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x13XV[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x13\0V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x14 W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x13\xE0V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\xC2W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x14v`@\x88\x01\x82a\x12\xACV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x14\x91\x81\x83a\x13\xCEV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14PV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\xC2W`?\x19\x87\x86\x03\x01\x84Ra\x14\xEA\x85\x83Qa\x12\xACV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\xCEV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\xC2W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x15m`@\x87\x01\x82a\x13\xCEV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15%V[\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\x15\xA6W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x15\xBEW__\xFD[\x845\x93Pa\x15\xCE` \x86\x01a\x15\x83V[\x92Pa\x15\xDC`@\x86\x01a\x15\x83V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x16\0W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x167W\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x16MW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x16\\W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x16sW__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x16\xB7W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\xCDW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x16\xDDW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\xF7Wa\x16\xF7a\x16zV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x17'Wa\x17'a\x16zV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x17>W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x17m`@\x83\x01\x85a\x12\xACV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xA0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x0C\xD48\x03\x80a\x0C\xD4\x839\x81\x01`@\x81\x90Ra\0.\x91a\0?V[`\x01`\x01`\xA0\x1B\x03\x16`\x80Ra\0lV[_` \x82\x84\x03\x12\x15a\0OW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0eW__\xFD[\x93\x92PPPV[`\x80Qa\x0C=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02UW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02y\x91\x90a\x0B,V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xE6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\n\x91\x90a\x0BGV[\x83Q\x90\x91P\x81\x10\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\x9Es\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x85\x83a\x05\xB4V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xB3\x90\x85\x90\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\x90`\x84\x01[`@\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\x0FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05-W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05Q\x91\x90a\x0BGV[a\x05[\x91\x90a\x0B^V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xB3\x90\x85\x90\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\x90`d\x01a\x04OV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x06\n\x90\x84\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\x90`d\x01a\x04OV[PPPV[_a\x06p\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\x07\x1A\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\nW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x8E\x91\x90a\x0B\x9CV[a\x06\nW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[``a\x07(\x84\x84_\x85a\x072V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xC4W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08BW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[__\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\x08j\x91\x90a\x0B\xBBV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xA4W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xA9V[``\x91P[P\x91P\x91Pa\x08\xB9\x82\x82\x86a\x08\xC4V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xD3WP\x81a\x07+V[\x82Q\x15a\x08\xE3W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03t\x91\x90a\x0B\xD1V[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\t8W__\xFD[PV[\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\x8BWa\t\x8Ba\t;V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xBAWa\t\xBAa\t;V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xD5W__\xFD[\x845a\t\xE0\x81a\t\x17V[\x93P` \x85\x015\x92P`@\x85\x015a\t\xF7\x81a\t\x17V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x12W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\"W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nz9,\xA4\xD4K\x0C\x1B\x8D\x91\x90a\x0B\x0BV[\x90Pa\x01L\x85\x85\x85\x84a\x023V[PPPPPV[`@Q\x7Fz~\r\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\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\x7F\0\0\0\0\0\0\0\0\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`$\x83\x01R_\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\x90\x91\x16\x90cz~\r\x92\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\tW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02-\x91\x90a\x0B/V[\x92\x91PPV[a\x02Us\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x043V[a\x02\x96s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\xF7V[`@Q\x7F\xE4hB\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\x83\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\x81\x16`$\x83\x01R\x85\x81\x16`D\x83\x01R`d\x82\x01\x85\x90R_\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\x90\x91\x16\x90c\xE4hB\xB7\x90`\x84\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\\W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x80\x91\x90a\x0B/V[\x82Q\x90\x91P\x81\x10\x15a\x03\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q_\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xF1\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xF2V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05kW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x8F\x91\x90a\x0B/V[a\x05\x99\x91\x90a\x0BFV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xF1\x90\x85\x90\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\x90`d\x01a\x04\x8DV[_a\x06S\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\x07\x02\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\xFDW\x80\x80` \x01\x90Q\x81\x01\x90a\x06q\x91\x90a\x0B~V[a\x06\xFDW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[PPPV[``a\x07\x10\x84\x84_\x85a\x07\x1AV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xACW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08*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\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x03\xEAV[__\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\x08R\x91\x90a\x0B\x9DV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x8CW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x91V[``\x91P[P\x91P\x91Pa\x08\xA1\x82\x82\x86a\x08\xACV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xBBWP\x81a\x07\x13V[\x82Q\x15a\x08\xCBW\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\xEA\x91\x90a\x0B\xB3V[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\t W__\xFD[PV[\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\tsWa\tsa\t#V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xA2Wa\t\xA2a\t#V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xBDW__\xFD[\x845a\t\xC8\x81a\x08\xFFV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xDF\x81a\x08\xFFV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xFAW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\nW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n$Wa\n$a\t#V[a\n7` `\x1F\x19`\x1F\x84\x01\x16\x01a\tyV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nKW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[_` \x82\x84\x03\x12\x15a\n|W__\xFD[\x815a\x07\x13\x81a\x08\xFFV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x9BW__\xFD[\x855a\n\xA6\x81a\x08\xFFV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xBD\x81a\x08\xFFV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xEEW__\xFD[Pa\n\xF7a\tPV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x1CW__\xFD[Pa\x0B%a\tPV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B?W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02-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[_` \x82\x84\x03\x12\x15a\x0B\x8EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x13W__\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\xFE\xA2dipfsX\"\x12 1\xA9_\tS$\x80\xC4eD\\\xF1\xA5F\x84\x08w?\xBD\x88\xEC\xC5\xCAl\x9C\xCA\x82\xDE\xCAb4\x08dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\x8C8\x03\x80a\r\x8C\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\xB6a\0\xD6_9_\x81\x81`\xCB\x01R\x81\x81a\x03\xE1\x01Ra\x04a\x01R_\x81\x81`S\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0C\xB6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c#\x17\x10\xA5\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xA6\xAA\x9C\xC0\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\n=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFB\xFAw\xCF`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B\xA6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x0EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x032\x91\x90a\x0B\xA6V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xC3\x91\x90a\x0B\xC1V[\x90Pa\x04\x06s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x84V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xA2W__\xFD[PZ\xF1\x15\x80\x15a\x04\xB4W=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05~\x90\x85\x90\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\x90`\x84\x01[`@\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\x7FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1C\x91\x90a\x0B\xC1V[a\x06&\x91\x90a\x0B\xD8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05~\x90\x85\x90\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\x90`d\x01a\x05\x1AV[_a\x06\xE0\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\x07\x94\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\x8FW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFE\x91\x90a\x0C\x16V[a\x07\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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x07\xA2\x84\x84_\x85a\x07\xACV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08>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\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\x07\x86V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\xBCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x86V[__\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\x08\xE4\x91\x90a\x0C5V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\t\x1EW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t#V[``\x91P[P\x91P\x91Pa\t3\x82\x82\x86a\t>V[\x97\x96PPPPPPPV[``\x83\x15a\tMWP\x81a\x07\xA5V[\x82Q\x15a\t]W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x86\x91\x90a\x0CKV[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\t\xB2W__\xFD[PV[\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\n\x05Wa\n\x05a\t\xB5V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n4Wa\n4a\t\xB5V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\nOW__\xFD[\x845a\nZ\x81a\t\x91V[\x93P` \x85\x015\x92P`@\x85\x015a\nq\x81a\t\x91V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x8CW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x9CW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xB6Wa\n\xB6a\t\xB5V[a\n\xC9` `\x1F\x19`\x1F\x84\x01\x16\x01a\n\x0BV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n\xDDW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0B\x12W__\xFD[\x855a\x0B\x1D\x81a\t\x91V[\x94P` \x86\x015\x93P`@\x86\x015a\x0B4\x81a\t\x91V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0BeW__\xFD[Pa\x0Bna\t\xE2V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x93W__\xFD[Pa\x0B\x9Ca\t\xE2V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xB6W__\xFD[\x81Qa\x07\xA5\x81a\t\x91V[_` \x82\x84\x03\x12\x15a\x0B\xD1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0C\x10W\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[_` \x82\x84\x03\x12\x15a\x0C&W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\xA5W__\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\xFE\xA2dipfsX\"\x12 #\xC6\x9F\x1F4j\x13~\xBA\xBD\x05\x83\xE0\xB1\x05\x8FN\xC6a;\x1Cg\xB1 >\x01O\x1B\xB3\x9BCgdsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 \x80\xC4k\xF0\xC6\x19\xCE\x07~;\x88Z\xE8M\x89\xB5F\xF0\xE2X\xB6\xE6\xE0\x88\xE6\xEB\xD68b&\x90\x9CdsolcC\0\x08\x1C\x003", ); #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] @@ -4054,64 +3970,6 @@ event logs(bytes); } } }; - /**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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolConstructor for constructorCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - } - }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. @@ -5034,31 +4892,17 @@ function failed() external view returns (bool); }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getBlockHeights(string,uint256,uint256)` and selector `0xfad06b8f`. + /**Function with signature `setUp()` and selector `0x0a9254e4`. ```solidity -function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); +function setUp() external; ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getBlockHeightsCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getBlockHeights(string,uint256,uint256)`](getBlockHeightsCall) function. + pub struct setUpCall; + ///Container type for the return parameters of the [`setUp()`](setUpCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getBlockHeightsReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >, - } + pub struct setUpReturn {} #[allow( non_camel_case_types, non_snake_case, @@ -5069,17 +4913,9 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte use alloy::sol_types as alloy_sol_types; { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - 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::String, - 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( @@ -5093,34 +4929,24 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsCall) -> Self { - (value.chainName, value.from, value.to) + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpCall) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getBlockHeightsCall { + impl ::core::convert::From> for setUpCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } + Self } } } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); + type UnderlyingSolTuple<'a> = (); #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >, - ); + type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -5134,42 +4960,39 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsReturn) -> Self { - (value.elements,) + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpReturn) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> - for getBlockHeightsReturn { + impl ::core::convert::From> for setUpReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } + Self {} } } } + impl setUpReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } #[automatically_derived] - impl alloy_sol_types::SolCall for getBlockHeightsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); + impl alloy_sol_types::SolCall for setUpCall { + type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); + type Return = setUpReturn; + type ReturnTuple<'a> = (); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getBlockHeights(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [250u8, 208u8, 107u8, 143u8]; + const SIGNATURE: &'static str = "setUp()"; + const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -5178,35 +5001,18 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte } #[inline] fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) + () } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) + setUpReturn::_tokenize(ret) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) + .map(Into::into) } #[inline] fn abi_decode_returns_validate( @@ -5215,40 +5021,32 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) + .map(Into::into) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getDigestLes(string,uint256,uint256)` and selector `0x44badbb6`. + /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. ```solidity -function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); +function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getDigestLesCall { + pub struct simulateForkAndTransferCall { + #[allow(missing_docs)] + pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, + pub sender: alloy::sol_types::private::Address, #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, + pub receiver: alloy::sol_types::private::Address, #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, + pub amount: alloy::sol_types::private::primitives::aliases::U256, } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getDigestLes(string,uint256,uint256)`](getDigestLesCall) function. + ///Container type for the return parameters of the [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getDigestLesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >, - } + pub struct simulateForkAndTransferReturn {} #[allow( non_camel_case_types, non_snake_case, @@ -5260,14 +5058,16 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa { #[doc(hidden)] 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::Uint<256>, ); #[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::primitives::aliases::U256, ); #[cfg(test)] @@ -5283,36 +5083,31 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesCall) -> Self { - (value.chainName, value.from, value.to) + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferCall) -> Self { + (value.forkAtBlock, value.sender, value.receiver, value.amount) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getDigestLesCall { + impl ::core::convert::From> + for simulateForkAndTransferCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, + forkAtBlock: tuple.0, + sender: tuple.1, + receiver: tuple.2, + amount: tuple.3, } } } } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array< - alloy::sol_types::sol_data::FixedBytes<32>, - >, - ); + type UnderlyingSolTuple<'a> = (); #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >, - ); + type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -5326,228 +5121,48 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesReturn) -> Self { - (value.elements,) + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferReturn) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getDigestLesReturn { + impl ::core::convert::From> + for simulateForkAndTransferReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } + Self {} } } } - #[automatically_derived] - impl alloy_sol_types::SolCall for getDigestLesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array< - alloy::sol_types::sol_data::FixedBytes<32>, - >, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getDigestLes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [68u8, 186u8, 219u8, 182u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaderHexes(string,uint256,uint256)` and selector `0x0813852a`. -```solidity -function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaderHexes(string,uint256,uint256)`](getHeaderHexesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeaderHexesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeaderHexesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesReturn) -> Self { - (value.elements,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getHeaderHexesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } - } + impl simulateForkAndTransferReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () } } #[automatically_derived] - impl alloy_sol_types::SolCall for getHeaderHexesCall { + impl alloy_sol_types::SolCall for simulateForkAndTransferCall { type Parameters<'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::Uint<256>, ); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Bytes, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); + type Return = simulateForkAndTransferReturn; + type ReturnTuple<'a> = (); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaderHexes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [8u8, 19u8, 133u8, 42u8]; + const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; + const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -5557,210 +5172,30 @@ function getHeaderHexes(string memory chainName, uint256 from, uint256 to) exter #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - ::tokenize( - &self.chainName, - ), as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaders(string,uint256,uint256)` and selector `0x1c0da81f`. -```solidity -function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaders(string,uint256,uint256)`](getHeadersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getHeadersReturn { - #[allow(missing_docs)] - pub headers: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersCall) -> Self { - (value.chainName, value.from, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersReturn) -> Self { - (value.headers,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getHeadersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { headers: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getHeadersCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Bytes; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaders(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [28u8, 13u8, 168u8, 31u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, + > as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), + ::tokenize( + &self.sender, + ), + ::tokenize( + &self.receiver, ), as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), + > as alloy_sol_types::SolType>::tokenize(&self.amount), ) } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) + simulateForkAndTransferReturn::_tokenize(ret) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) + .map(Into::into) } #[inline] fn abi_decode_returns_validate( @@ -5769,10 +5204,7 @@ function getHeaders(string memory chainName, uint256 from, uint256 to) external as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers - }) + .map(Into::into) } } }; @@ -6726,17 +6158,17 @@ function targetSenders() external view returns (address[] memory targetedSenders }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testFindKnownAncestor()` and selector `0x91ae19ca`. + /**Function with signature `testPellBedrockStrategy()` and selector `0x95902669`. ```solidity -function testFindKnownAncestor() external view; +function testPellBedrockStrategy() external; ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testFindKnownAncestorCall; - ///Container type for the return parameters of the [`testFindKnownAncestor()`](testFindKnownAncestorCall) function. + pub struct testPellBedrockStrategyCall; + ///Container type for the return parameters of the [`testPellBedrockStrategy()`](testPellBedrockStrategyCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testFindKnownAncestorReturn {} + pub struct testPellBedrockStrategyReturn {} #[allow( non_camel_case_types, non_snake_case, @@ -6763,16 +6195,16 @@ function testFindKnownAncestor() external view; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: testFindKnownAncestorCall) -> Self { + fn from(value: testPellBedrockStrategyCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for testFindKnownAncestorCall { + for testPellBedrockStrategyCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -6796,43 +6228,43 @@ function testFindKnownAncestor() external view; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: testFindKnownAncestorReturn) -> Self { + fn from(value: testPellBedrockStrategyReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for testFindKnownAncestorReturn { + for testPellBedrockStrategyReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } } } - impl testFindKnownAncestorReturn { + impl testPellBedrockStrategyReturn { fn _tokenize( &self, - ) -> ::ReturnToken< + ) -> ::ReturnToken< '_, > { () } } #[automatically_derived] - impl alloy_sol_types::SolCall for testFindKnownAncestorCall { + impl alloy_sol_types::SolCall for testPellBedrockStrategyCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testFindKnownAncestorReturn; + type Return = testPellBedrockStrategyReturn; type ReturnTuple<'a> = (); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testFindKnownAncestor()"; - const SELECTOR: [u8; 4] = [145u8, 174u8, 25u8, 202u8]; + const SIGNATURE: &'static str = "testPellBedrockStrategy()"; + const SELECTOR: [u8; 4] = [149u8, 144u8, 38u8, 105u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -6845,7 +6277,7 @@ function testFindKnownAncestor() external view; } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testFindKnownAncestorReturn::_tokenize(ret) + testPellBedrockStrategyReturn::_tokenize(ret) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { @@ -6867,17 +6299,22 @@ function testFindKnownAncestor() external view; }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testFindUnknownAncestor()` and selector `0x4643658e`. + /**Function with signature `token()` and selector `0xfc0c546a`. ```solidity -function testFindUnknownAncestor() external; +function token() external view returns (address); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testFindUnknownAncestorCall; - ///Container type for the return parameters of the [`testFindUnknownAncestor()`](testFindUnknownAncestorCall) function. + pub struct tokenCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`token()`](tokenCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testFindUnknownAncestorReturn {} + pub struct tokenReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } #[allow( non_camel_case_types, non_snake_case, @@ -6904,16 +6341,14 @@ function testFindUnknownAncestor() external; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testFindUnknownAncestorCall) -> Self { + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> - for testFindUnknownAncestorCall { + impl ::core::convert::From> for tokenCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -6921,9 +6356,9 @@ function testFindUnknownAncestor() external; } { #[doc(hidden)] - 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( @@ -6937,43 +6372,32 @@ function testFindUnknownAncestor() external; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testFindUnknownAncestorReturn) -> Self { - () + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenReturn) -> Self { + (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> - for testFindUnknownAncestorReturn { + impl ::core::convert::From> for tokenReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} + Self { _0: tuple.0 } } } } - impl testFindUnknownAncestorReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } #[automatically_derived] - impl alloy_sol_types::SolCall for testFindUnknownAncestorCall { + impl alloy_sol_types::SolCall for tokenCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testFindUnknownAncestorReturn; - type ReturnTuple<'a> = (); + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testFindUnknownAncestor()"; - const SELECTOR: [u8; 4] = [70u8, 67u8, 101u8, 142u8]; + const SIGNATURE: &'static str = "token()"; + const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -6986,14 +6410,21 @@ function testFindUnknownAncestor() external; } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testFindUnknownAncestorReturn::_tokenize(ret) + ( + ::tokenize( + ret, + ), + ) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) } #[inline] fn abi_decode_returns_validate( @@ -7002,14 +6433,17 @@ function testFindUnknownAncestor() external; as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) } } }; - ///Container for all the [`FullRelayFindAncestorTest`](self) function calls. + ///Container for all the [`PellBedRockStrategyForked`](self) function calls. #[derive(serde::Serialize, serde::Deserialize)] #[derive()] - pub enum FullRelayFindAncestorTestCalls { + pub enum PellBedRockStrategyForkedCalls { #[allow(missing_docs)] IS_TEST(IS_TESTCall), #[allow(missing_docs)] @@ -7023,13 +6457,9 @@ function testFindUnknownAncestor() external; #[allow(missing_docs)] failed(failedCall), #[allow(missing_docs)] - getBlockHeights(getBlockHeightsCall), - #[allow(missing_docs)] - getDigestLes(getDigestLesCall), - #[allow(missing_docs)] - getHeaderHexes(getHeaderHexesCall), + setUp(setUpCall), #[allow(missing_docs)] - getHeaders(getHeadersCall), + simulateForkAndTransfer(simulateForkAndTransferCall), #[allow(missing_docs)] targetArtifactSelectors(targetArtifactSelectorsCall), #[allow(missing_docs)] @@ -7043,12 +6473,12 @@ function testFindUnknownAncestor() external; #[allow(missing_docs)] targetSenders(targetSendersCall), #[allow(missing_docs)] - testFindKnownAncestor(testFindKnownAncestorCall), + testPellBedrockStrategy(testPellBedrockStrategyCall), #[allow(missing_docs)] - testFindUnknownAncestor(testFindUnknownAncestorCall), + token(tokenCall), } #[automatically_derived] - impl FullRelayFindAncestorTestCalls { + impl PellBedRockStrategyForkedCalls { /// All the selectors of this enum. /// /// Note that the selectors might not be in the same order as the variants. @@ -7056,31 +6486,29 @@ function testFindUnknownAncestor() external; /// /// Prefer using `SolInterface` methods instead. pub const SELECTORS: &'static [[u8; 4usize]] = &[ - [8u8, 19u8, 133u8, 42u8], - [28u8, 13u8, 168u8, 31u8], + [10u8, 146u8, 84u8, 228u8], [30u8, 215u8, 131u8, 28u8], [42u8, 222u8, 56u8, 128u8], [62u8, 94u8, 60u8, 35u8], [63u8, 114u8, 134u8, 244u8], - [68u8, 186u8, 219u8, 182u8], - [70u8, 67u8, 101u8, 142u8], [102u8, 217u8, 169u8, 160u8], [133u8, 34u8, 108u8, 129u8], [145u8, 106u8, 23u8, 198u8], - [145u8, 174u8, 25u8, 202u8], + [149u8, 144u8, 38u8, 105u8], [176u8, 70u8, 79u8, 220u8], [181u8, 80u8, 138u8, 169u8], [186u8, 65u8, 79u8, 166u8], [226u8, 12u8, 159u8, 113u8], + [249u8, 206u8, 14u8, 90u8], [250u8, 118u8, 38u8, 212u8], - [250u8, 208u8, 107u8, 143u8], + [252u8, 12u8, 84u8, 106u8], ]; } #[automatically_derived] - impl alloy_sol_types::SolInterface for FullRelayFindAncestorTestCalls { - const NAME: &'static str = "FullRelayFindAncestorTestCalls"; + impl alloy_sol_types::SolInterface for PellBedRockStrategyForkedCalls { + const NAME: &'static str = "PellBedRockStrategyForkedCalls"; const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 18usize; + const COUNT: usize = 16usize; #[inline] fn selector(&self) -> [u8; 4] { match self { @@ -7098,17 +6526,9 @@ function testFindUnknownAncestor() external; ::SELECTOR } Self::failed(_) => ::SELECTOR, - Self::getBlockHeights(_) => { - ::SELECTOR - } - Self::getDigestLes(_) => { - ::SELECTOR - } - Self::getHeaderHexes(_) => { - ::SELECTOR - } - Self::getHeaders(_) => { - ::SELECTOR + Self::setUp(_) => ::SELECTOR, + Self::simulateForkAndTransfer(_) => { + ::SELECTOR } Self::targetArtifactSelectors(_) => { ::SELECTOR @@ -7128,12 +6548,10 @@ function testFindUnknownAncestor() external; Self::targetSenders(_) => { ::SELECTOR } - Self::testFindKnownAncestor(_) => { - ::SELECTOR - } - Self::testFindUnknownAncestor(_) => { - ::SELECTOR + Self::testPellBedrockStrategy(_) => { + ::SELECTOR } + Self::token(_) => ::SELECTOR, } } #[inline] @@ -7152,200 +6570,174 @@ function testFindUnknownAncestor() external; ) -> alloy_sol_types::Result { static DECODE_SHIMS: &[fn( &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayFindAncestorTestCalls::getHeaderHexes) - } - getHeaderHexes - }, + ) -> alloy_sol_types::Result] = &[ { - fn getHeaders( + fn setUp( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayFindAncestorTestCalls::getHeaders) + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(PellBedRockStrategyForkedCalls::setUp) } - getHeaders + setUp }, { fn excludeSenders( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayFindAncestorTestCalls::excludeSenders) + .map(PellBedRockStrategyForkedCalls::excludeSenders) } excludeSenders }, { fn targetInterfaces( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayFindAncestorTestCalls::targetInterfaces) + .map(PellBedRockStrategyForkedCalls::targetInterfaces) } targetInterfaces }, { fn targetSenders( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayFindAncestorTestCalls::targetSenders) + .map(PellBedRockStrategyForkedCalls::targetSenders) } targetSenders }, { fn targetContracts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayFindAncestorTestCalls::targetContracts) + .map(PellBedRockStrategyForkedCalls::targetContracts) } targetContracts }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayFindAncestorTestCalls::getDigestLes) - } - getDigestLes - }, - { - fn testFindUnknownAncestor( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayFindAncestorTestCalls::testFindUnknownAncestor) - } - testFindUnknownAncestor - }, { fn targetArtifactSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayFindAncestorTestCalls::targetArtifactSelectors) + .map(PellBedRockStrategyForkedCalls::targetArtifactSelectors) } targetArtifactSelectors }, { fn targetArtifacts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayFindAncestorTestCalls::targetArtifacts) + .map(PellBedRockStrategyForkedCalls::targetArtifacts) } targetArtifacts }, { fn targetSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayFindAncestorTestCalls::targetSelectors) + .map(PellBedRockStrategyForkedCalls::targetSelectors) } targetSelectors }, { - fn testFindKnownAncestor( + fn testPellBedrockStrategy( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( + ) -> alloy_sol_types::Result { + ::abi_decode_raw( data, ) - .map(FullRelayFindAncestorTestCalls::testFindKnownAncestor) + .map(PellBedRockStrategyForkedCalls::testPellBedrockStrategy) } - testFindKnownAncestor + testPellBedrockStrategy }, { fn excludeSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayFindAncestorTestCalls::excludeSelectors) + .map(PellBedRockStrategyForkedCalls::excludeSelectors) } excludeSelectors }, { fn excludeArtifacts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayFindAncestorTestCalls::excludeArtifacts) + .map(PellBedRockStrategyForkedCalls::excludeArtifacts) } excludeArtifacts }, { fn failed( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw(data) - .map(FullRelayFindAncestorTestCalls::failed) + .map(PellBedRockStrategyForkedCalls::failed) } failed }, { fn excludeContracts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayFindAncestorTestCalls::excludeContracts) + .map(PellBedRockStrategyForkedCalls::excludeContracts) } excludeContracts }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellBedRockStrategyForkedCalls::simulateForkAndTransfer) + } + simulateForkAndTransfer + }, { fn IS_TEST( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw(data) - .map(FullRelayFindAncestorTestCalls::IS_TEST) + .map(PellBedRockStrategyForkedCalls::IS_TEST) } IS_TEST }, { - fn getBlockHeights( + fn token( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayFindAncestorTestCalls::getBlockHeights) + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(PellBedRockStrategyForkedCalls::token) } - getBlockHeights + token }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { @@ -7366,204 +6758,182 @@ function testFindUnknownAncestor() external; ) -> alloy_sol_types::Result { static DECODE_VALIDATE_SHIMS: &[fn( &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayFindAncestorTestCalls::getHeaderHexes) - } - getHeaderHexes - }, + ) -> alloy_sol_types::Result] = &[ { - fn getHeaders( + fn setUp( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( data, ) - .map(FullRelayFindAncestorTestCalls::getHeaders) + .map(PellBedRockStrategyForkedCalls::setUp) } - getHeaders + setUp }, { fn excludeSenders( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindAncestorTestCalls::excludeSenders) + .map(PellBedRockStrategyForkedCalls::excludeSenders) } excludeSenders }, { fn targetInterfaces( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindAncestorTestCalls::targetInterfaces) + .map(PellBedRockStrategyForkedCalls::targetInterfaces) } targetInterfaces }, { fn targetSenders( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindAncestorTestCalls::targetSenders) + .map(PellBedRockStrategyForkedCalls::targetSenders) } targetSenders }, { fn targetContracts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindAncestorTestCalls::targetContracts) + .map(PellBedRockStrategyForkedCalls::targetContracts) } targetContracts }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayFindAncestorTestCalls::getDigestLes) - } - getDigestLes - }, - { - fn testFindUnknownAncestor( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayFindAncestorTestCalls::testFindUnknownAncestor) - } - testFindUnknownAncestor - }, { fn targetArtifactSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindAncestorTestCalls::targetArtifactSelectors) + .map(PellBedRockStrategyForkedCalls::targetArtifactSelectors) } targetArtifactSelectors }, { fn targetArtifacts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindAncestorTestCalls::targetArtifacts) + .map(PellBedRockStrategyForkedCalls::targetArtifacts) } targetArtifacts }, { fn targetSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindAncestorTestCalls::targetSelectors) + .map(PellBedRockStrategyForkedCalls::targetSelectors) } targetSelectors }, { - fn testFindKnownAncestor( + fn testPellBedrockStrategy( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( data, ) - .map(FullRelayFindAncestorTestCalls::testFindKnownAncestor) + .map(PellBedRockStrategyForkedCalls::testPellBedrockStrategy) } - testFindKnownAncestor + testPellBedrockStrategy }, { fn excludeSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindAncestorTestCalls::excludeSelectors) + .map(PellBedRockStrategyForkedCalls::excludeSelectors) } excludeSelectors }, { fn excludeArtifacts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindAncestorTestCalls::excludeArtifacts) + .map(PellBedRockStrategyForkedCalls::excludeArtifacts) } excludeArtifacts }, { fn failed( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindAncestorTestCalls::failed) + .map(PellBedRockStrategyForkedCalls::failed) } failed }, { fn excludeContracts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindAncestorTestCalls::excludeContracts) + .map(PellBedRockStrategyForkedCalls::excludeContracts) } excludeContracts }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellBedRockStrategyForkedCalls::simulateForkAndTransfer) + } + simulateForkAndTransfer + }, { fn IS_TEST( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayFindAncestorTestCalls::IS_TEST) + .map(PellBedRockStrategyForkedCalls::IS_TEST) } IS_TEST }, { - fn getBlockHeights( + fn token( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( data, ) - .map(FullRelayFindAncestorTestCalls::getBlockHeights) + .map(PellBedRockStrategyForkedCalls::token) } - getBlockHeights + token }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { @@ -7605,24 +6975,14 @@ function testFindUnknownAncestor() external; Self::failed(inner) => { ::abi_encoded_size(inner) } - Self::getBlockHeights(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getDigestLes(inner) => { - ::abi_encoded_size( - inner, - ) + Self::setUp(inner) => { + ::abi_encoded_size(inner) } - Self::getHeaderHexes(inner) => { - ::abi_encoded_size( + Self::simulateForkAndTransfer(inner) => { + ::abi_encoded_size( inner, ) } - Self::getHeaders(inner) => { - ::abi_encoded_size(inner) - } Self::targetArtifactSelectors(inner) => { ::abi_encoded_size( inner, @@ -7653,15 +7013,13 @@ function testFindUnknownAncestor() external; inner, ) } - Self::testFindKnownAncestor(inner) => { - ::abi_encoded_size( + Self::testPellBedrockStrategy(inner) => { + ::abi_encoded_size( inner, ) } - Self::testFindUnknownAncestor(inner) => { - ::abi_encoded_size( - inner, - ) + Self::token(inner) => { + ::abi_encoded_size(inner) } } } @@ -7698,26 +7056,11 @@ function testFindUnknownAncestor() external; Self::failed(inner) => { ::abi_encode_raw(inner, out) } - Self::getBlockHeights(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getDigestLes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encode_raw( - inner, - out, - ) + Self::setUp(inner) => { + ::abi_encode_raw(inner, out) } - Self::getHeaders(inner) => { - ::abi_encode_raw( + Self::simulateForkAndTransfer(inner) => { + ::abi_encode_raw( inner, out, ) @@ -7758,25 +7101,22 @@ function testFindUnknownAncestor() external; out, ) } - Self::testFindKnownAncestor(inner) => { - ::abi_encode_raw( + Self::testPellBedrockStrategy(inner) => { + ::abi_encode_raw( inner, out, ) } - Self::testFindUnknownAncestor(inner) => { - ::abi_encode_raw( - inner, - out, - ) + Self::token(inner) => { + ::abi_encode_raw(inner, out) } } } } - ///Container for all the [`FullRelayFindAncestorTest`](self) events. + ///Container for all the [`PellBedRockStrategyForked`](self) events. #[derive(serde::Serialize, serde::Deserialize)] #[derive()] - pub enum FullRelayFindAncestorTestEvents { + pub enum PellBedRockStrategyForkedEvents { #[allow(missing_docs)] log(log), #[allow(missing_docs)] @@ -7823,7 +7163,7 @@ function testFindUnknownAncestor() external; logs(logs), } #[automatically_derived] - impl FullRelayFindAncestorTestEvents { + impl PellBedRockStrategyForkedEvents { /// All the selectors of this enum. /// /// Note that the selectors might not be in the same order as the variants. @@ -7944,8 +7284,8 @@ function testFindUnknownAncestor() external; ]; } #[automatically_derived] - impl alloy_sol_types::SolEventInterface for FullRelayFindAncestorTestEvents { - const NAME: &'static str = "FullRelayFindAncestorTestEvents"; + impl alloy_sol_types::SolEventInterface for PellBedRockStrategyForkedEvents { + const NAME: &'static str = "PellBedRockStrategyForkedEvents"; const COUNT: usize = 22usize; fn decode_raw_log( topics: &[alloy_sol_types::Word], @@ -8123,7 +7463,7 @@ function testFindUnknownAncestor() external; } } #[automatically_derived] - impl alloy_sol_types::private::IntoLogData for FullRelayFindAncestorTestEvents { + impl alloy_sol_types::private::IntoLogData for PellBedRockStrategyForkedEvents { fn to_log_data(&self) -> alloy_sol_types::private::LogData { match self { Self::log(inner) => { @@ -8266,9 +7606,9 @@ function testFindUnknownAncestor() external; } } use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`FullRelayFindAncestorTest`](self) contract instance. + /**Creates a new wrapper around an on-chain [`PellBedRockStrategyForked`](self) contract instance. -See the [wrapper's documentation](`FullRelayFindAncestorTestInstance`) for more details.*/ +See the [wrapper's documentation](`PellBedRockStrategyForkedInstance`) for more details.*/ #[inline] pub const fn new< P: alloy_contract::private::Provider, @@ -8276,8 +7616,8 @@ See the [wrapper's documentation](`FullRelayFindAncestorTestInstance`) for more >( address: alloy_sol_types::private::Address, provider: P, - ) -> FullRelayFindAncestorTestInstance { - FullRelayFindAncestorTestInstance::::new(address, provider) + ) -> PellBedRockStrategyForkedInstance { + PellBedRockStrategyForkedInstance::::new(address, provider) } /**Deploys this contract using the given `provider` and constructor arguments, if any. @@ -8291,9 +7631,9 @@ For more fine-grained control over the deployment process, use [`deploy_builder` >( provider: P, ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, + Output = alloy_contract::Result>, > { - FullRelayFindAncestorTestInstance::::deploy(provider) + PellBedRockStrategyForkedInstance::::deploy(provider) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` and constructor arguments, if any. @@ -8305,12 +7645,12 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ P: alloy_contract::private::Provider, N: alloy_contract::private::Network, >(provider: P) -> alloy_contract::RawCallBuilder { - FullRelayFindAncestorTestInstance::::deploy_builder(provider) + PellBedRockStrategyForkedInstance::::deploy_builder(provider) } - /**A [`FullRelayFindAncestorTest`](self) instance. + /**A [`PellBedRockStrategyForked`](self) instance. Contains type-safe methods for interacting with an on-chain instance of the -[`FullRelayFindAncestorTest`](self) contract located at a given `address`, using a given +[`PellBedRockStrategyForked`](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!) @@ -8319,7 +7659,7 @@ 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 FullRelayFindAncestorTestInstance< + pub struct PellBedRockStrategyForkedInstance< P, N = alloy_contract::private::Ethereum, > { @@ -8328,10 +7668,10 @@ See the [module-level documentation](self) for all the available methods.*/ _network: ::core::marker::PhantomData, } #[automatically_derived] - impl ::core::fmt::Debug for FullRelayFindAncestorTestInstance { + impl ::core::fmt::Debug for PellBedRockStrategyForkedInstance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("FullRelayFindAncestorTestInstance") + f.debug_tuple("PellBedRockStrategyForkedInstance") .field(&self.address) .finish() } @@ -8341,10 +7681,10 @@ See the [module-level documentation](self) for all the available methods.*/ impl< P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - > FullRelayFindAncestorTestInstance { - /**Creates a new wrapper around an on-chain [`FullRelayFindAncestorTest`](self) contract instance. + > PellBedRockStrategyForkedInstance { + /**Creates a new wrapper around an on-chain [`PellBedRockStrategyForked`](self) contract instance. -See the [wrapper's documentation](`FullRelayFindAncestorTestInstance`) for more details.*/ +See the [wrapper's documentation](`PellBedRockStrategyForkedInstance`) for more details.*/ #[inline] pub const fn new( address: alloy_sol_types::private::Address, @@ -8364,7 +7704,7 @@ For more fine-grained control over the deployment process, use [`deploy_builder` #[inline] pub async fn deploy( provider: P, - ) -> alloy_contract::Result> { + ) -> alloy_contract::Result> { let call_builder = Self::deploy_builder(provider); let contract_address = call_builder.deploy().await?; Ok(Self::new(contract_address, call_builder.provider)) @@ -8402,11 +7742,11 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ &self.provider } } - impl FullRelayFindAncestorTestInstance<&P, N> { + impl PellBedRockStrategyForkedInstance<&P, N> { /// Clones the provider and returns a new instance with the cloned provider. #[inline] - pub fn with_cloned_provider(self) -> FullRelayFindAncestorTestInstance { - FullRelayFindAncestorTestInstance { + pub fn with_cloned_provider(self) -> PellBedRockStrategyForkedInstance { + PellBedRockStrategyForkedInstance { address: self.address, provider: ::core::clone::Clone::clone(&self.provider), _network: ::core::marker::PhantomData, @@ -8418,7 +7758,7 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ impl< P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - > FullRelayFindAncestorTestInstance { + > PellBedRockStrategyForkedInstance { /// 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 @@ -8461,63 +7801,24 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { self.call_builder(&failedCall) } - ///Creates a new call builder for the [`getBlockHeights`] function. - pub fn getBlockHeights( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getBlockHeightsCall, N> { - self.call_builder( - &getBlockHeightsCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getDigestLes`] function. - pub fn getDigestLes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getDigestLesCall, N> { - self.call_builder( - &getDigestLesCall { - chainName, - from, - to, - }, - ) + ///Creates a new call builder for the [`setUp`] function. + pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { + self.call_builder(&setUpCall) } - ///Creates a new call builder for the [`getHeaderHexes`] function. - pub fn getHeaderHexes( + ///Creates a new call builder for the [`simulateForkAndTransfer`] function. + pub fn simulateForkAndTransfer( &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeaderHexesCall, N> { + forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + sender: alloy::sol_types::private::Address, + receiver: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { self.call_builder( - &getHeaderHexesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaders`] function. - pub fn getHeaders( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeadersCall, N> { - self.call_builder( - &getHeadersCall { - chainName, - from, - to, + &simulateForkAndTransferCall { + forkAtBlock, + sender, + receiver, + amount, }, ) } @@ -8557,17 +7858,15 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { self.call_builder(&targetSendersCall) } - ///Creates a new call builder for the [`testFindKnownAncestor`] function. - pub fn testFindKnownAncestor( + ///Creates a new call builder for the [`testPellBedrockStrategy`] function. + pub fn testPellBedrockStrategy( &self, - ) -> alloy_contract::SolCallBuilder<&P, testFindKnownAncestorCall, N> { - self.call_builder(&testFindKnownAncestorCall) + ) -> alloy_contract::SolCallBuilder<&P, testPellBedrockStrategyCall, N> { + self.call_builder(&testPellBedrockStrategyCall) } - ///Creates a new call builder for the [`testFindUnknownAncestor`] function. - pub fn testFindUnknownAncestor( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testFindUnknownAncestorCall, N> { - self.call_builder(&testFindUnknownAncestorCall) + ///Creates a new call builder for the [`token`] function. + pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { + self.call_builder(&tokenCall) } } /// Event filters. @@ -8575,7 +7874,7 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ impl< P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - > FullRelayFindAncestorTestInstance { + > PellBedRockStrategyForkedInstance { /// 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. diff --git a/crates/bindings/src/pell_bedrock_strategy.rs b/crates/bindings/src/pell_bedrock_strategy.rs new file mode 100644 index 000000000..a8f23b247 --- /dev/null +++ b/crates/bindings/src/pell_bedrock_strategy.rs @@ -0,0 +1,1808 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface PellBedrockStrategy { + struct StrategySlippageArgs { + uint256 amountOutMin; + } + + event TokenOutput(address tokenReceived, uint256 amountOut); + + constructor(address _bedrockStrategy, address _pellStrategy); + + function bedrockStrategy() external view returns (address); + function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; + function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amount, address recipient, StrategySlippageArgs memory args) external; + function pellStrategy() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_bedrockStrategy", + "type": "address", + "internalType": "contract BedrockStrategy" + }, + { + "name": "_pellStrategy", + "type": "address", + "internalType": "contract PellStrategy" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "bedrockStrategy", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract BedrockStrategy" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "handleGatewayMessage", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "message", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessageWithSlippageArgs", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "args", + "type": "tuple", + "internalType": "struct StrategySlippageArgs", + "components": [ + { + "name": "amountOutMin", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "pellStrategy", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract PellStrategy" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "TokenOutput", + "inputs": [ + { + "name": "tokenReceived", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "amountOut", + "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 PellBedrockStrategy { + use super::*; + use alloy::sol_types as 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\r\x8C8\x03\x80a\r\x8C\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\xB6a\0\xD6_9_\x81\x81`\xCB\x01R\x81\x81a\x03\xE1\x01Ra\x04a\x01R_\x81\x81`S\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0C\xB6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c#\x17\x10\xA5\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xA6\xAA\x9C\xC0\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\n=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFB\xFAw\xCF`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B\xA6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x0EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x032\x91\x90a\x0B\xA6V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xC3\x91\x90a\x0B\xC1V[\x90Pa\x04\x06s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x84V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xA2W__\xFD[PZ\xF1\x15\x80\x15a\x04\xB4W=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05~\x90\x85\x90\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\x90`\x84\x01[`@\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\x7FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1C\x91\x90a\x0B\xC1V[a\x06&\x91\x90a\x0B\xD8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05~\x90\x85\x90\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\x90`d\x01a\x05\x1AV[_a\x06\xE0\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\x07\x94\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\x8FW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFE\x91\x90a\x0C\x16V[a\x07\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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x07\xA2\x84\x84_\x85a\x07\xACV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08>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\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\x07\x86V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\xBCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x86V[__\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\x08\xE4\x91\x90a\x0C5V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\t\x1EW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t#V[``\x91P[P\x91P\x91Pa\t3\x82\x82\x86a\t>V[\x97\x96PPPPPPPV[``\x83\x15a\tMWP\x81a\x07\xA5V[\x82Q\x15a\t]W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x86\x91\x90a\x0CKV[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\t\xB2W__\xFD[PV[\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\n\x05Wa\n\x05a\t\xB5V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n4Wa\n4a\t\xB5V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\nOW__\xFD[\x845a\nZ\x81a\t\x91V[\x93P` \x85\x015\x92P`@\x85\x015a\nq\x81a\t\x91V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x8CW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x9CW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xB6Wa\n\xB6a\t\xB5V[a\n\xC9` `\x1F\x19`\x1F\x84\x01\x16\x01a\n\x0BV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n\xDDW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0B\x12W__\xFD[\x855a\x0B\x1D\x81a\t\x91V[\x94P` \x86\x015\x93P`@\x86\x015a\x0B4\x81a\t\x91V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0BeW__\xFD[Pa\x0Bna\t\xE2V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x93W__\xFD[Pa\x0B\x9Ca\t\xE2V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xB6W__\xFD[\x81Qa\x07\xA5\x81a\t\x91V[_` \x82\x84\x03\x12\x15a\x0B\xD1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0C\x10W\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[_` \x82\x84\x03\x12\x15a\x0C&W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\xA5W__\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\xFE\xA2dipfsX\"\x12 #\xC6\x9F\x1F4j\x13~\xBA\xBD\x05\x83\xE0\xB1\x05\x8FN\xC6a;\x1Cg\xB1 >\x01O\x1B\xB3\x9BCgdsolcC\0\x08\x1C\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x608060405234801561000f575f5ffd5b506004361061004a575f3560e01c8063231710a51461004e57806350634c0e1461009e5780637f814f35146100b3578063a6aa9cc0146100c6575b5f5ffd5b6100757f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200160405180910390f35b6100b16100ac366004610a3c565b6100ed565b005b6100b16100c1366004610afe565b610117565b6100757f000000000000000000000000000000000000000000000000000000000000000081565b5f818060200190518101906101029190610b82565b905061011085858584610117565b5050505050565b61013973ffffffffffffffffffffffffffffffffffffffff85163330866104c0565b61017a73ffffffffffffffffffffffffffffffffffffffff85167f000000000000000000000000000000000000000000000000000000000000000085610584565b604080516020810182525f815290517f7f814f3500000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff868116600483015260248201869052306044830152915160648201527f000000000000000000000000000000000000000000000000000000000000000090911690637f814f35906084015f604051808303815f87803b158015610222575f5ffd5b505af1158015610234573d5f5f3e3d5ffd5b505050505f7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663fbfa77cf6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156102a2573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906102c69190610ba6565b73ffffffffffffffffffffffffffffffffffffffff166359f3d39b6040518163ffffffff1660e01b8152600401602060405180830381865afa15801561030e573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103329190610ba6565b6040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201529091505f9073ffffffffffffffffffffffffffffffffffffffff8316906370a0823190602401602060405180830381865afa15801561039f573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103c39190610bc1565b905061040673ffffffffffffffffffffffffffffffffffffffff83167f000000000000000000000000000000000000000000000000000000000000000083610584565b6040517f7f814f3500000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8381166004830152602482018390528581166044830152845160648301527f00000000000000000000000000000000000000000000000000000000000000001690637f814f35906084015f604051808303815f87803b1580156104a2575f5ffd5b505af11580156104b4573d5f5f3e3d5ffd5b50505050505050505050565b60405173ffffffffffffffffffffffffffffffffffffffff8085166024830152831660448201526064810182905261057e9085907f23b872dd00000000000000000000000000000000000000000000000000000000906084015b60408051601f198184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff000000000000000000000000000000000000000000000000000000009093169290921790915261067f565b50505050565b6040517fdd62ed3e00000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff83811660248301525f91839186169063dd62ed3e90604401602060405180830381865afa1580156105f8573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061061c9190610bc1565b6106269190610bd8565b60405173ffffffffffffffffffffffffffffffffffffffff851660248201526044810182905290915061057e9085907f095ea7b3000000000000000000000000000000000000000000000000000000009060640161051a565b5f6106e0826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166107949092919063ffffffff16565b80519091501561078f57808060200190518101906106fe9190610c16565b61078f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f7420737563636565640000000000000000000000000000000000000000000060648201526084015b60405180910390fd5b505050565b60606107a284845f856107ac565b90505b9392505050565b60608247101561083e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c00000000000000000000000000000000000000000000000000006064820152608401610786565b73ffffffffffffffffffffffffffffffffffffffff85163b6108bc576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606401610786565b5f5f8673ffffffffffffffffffffffffffffffffffffffff1685876040516108e49190610c35565b5f6040518083038185875af1925050503d805f811461091e576040519150601f19603f3d011682016040523d82523d5f602084013e610923565b606091505b509150915061093382828661093e565b979650505050505050565b6060831561094d5750816107a5565b82511561095d5782518084602001fd5b816040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107869190610c4b565b73ffffffffffffffffffffffffffffffffffffffff811681146109b2575f5ffd5b50565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b6040516020810167ffffffffffffffff81118282101715610a0557610a056109b5565b60405290565b604051601f8201601f1916810167ffffffffffffffff81118282101715610a3457610a346109b5565b604052919050565b5f5f5f5f60808587031215610a4f575f5ffd5b8435610a5a81610991565b9350602085013592506040850135610a7181610991565b9150606085013567ffffffffffffffff811115610a8c575f5ffd5b8501601f81018713610a9c575f5ffd5b803567ffffffffffffffff811115610ab657610ab66109b5565b610ac96020601f19601f84011601610a0b565b818152886020838501011115610add575f5ffd5b816020840160208301375f6020838301015280935050505092959194509250565b5f5f5f5f8486036080811215610b12575f5ffd5b8535610b1d81610991565b9450602086013593506040860135610b3481610991565b925060207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa082011215610b65575f5ffd5b50610b6e6109e2565b606095909501358552509194909350909190565b5f6020828403128015610b93575f5ffd5b50610b9c6109e2565b9151825250919050565b5f60208284031215610bb6575f5ffd5b81516107a581610991565b5f60208284031215610bd1575f5ffd5b5051919050565b80820180821115610c10577f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b92915050565b5f60208284031215610c26575f5ffd5b815180151581146107a5575f5ffd5b5f82518060208501845e5f920191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f8301168401019150509291505056fea264697066735822122023c69f1f346a137ebabd0583e0b1058f4ec6613b1c67b1203e014f1bb39b436764736f6c634300081c0033 + /// ``` + #[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#\x17\x10\xA5\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xA6\xAA\x9C\xC0\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\n=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFB\xFAw\xCF`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B\xA6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x0EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x032\x91\x90a\x0B\xA6V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xC3\x91\x90a\x0B\xC1V[\x90Pa\x04\x06s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x84V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xA2W__\xFD[PZ\xF1\x15\x80\x15a\x04\xB4W=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05~\x90\x85\x90\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\x90`\x84\x01[`@\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\x7FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1C\x91\x90a\x0B\xC1V[a\x06&\x91\x90a\x0B\xD8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05~\x90\x85\x90\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\x90`d\x01a\x05\x1AV[_a\x06\xE0\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\x07\x94\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\x8FW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFE\x91\x90a\x0C\x16V[a\x07\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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x07\xA2\x84\x84_\x85a\x07\xACV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08>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\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\x07\x86V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\xBCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x86V[__\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\x08\xE4\x91\x90a\x0C5V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\t\x1EW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t#V[``\x91P[P\x91P\x91Pa\t3\x82\x82\x86a\t>V[\x97\x96PPPPPPPV[``\x83\x15a\tMWP\x81a\x07\xA5V[\x82Q\x15a\t]W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x86\x91\x90a\x0CKV[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\t\xB2W__\xFD[PV[\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\n\x05Wa\n\x05a\t\xB5V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n4Wa\n4a\t\xB5V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\nOW__\xFD[\x845a\nZ\x81a\t\x91V[\x93P` \x85\x015\x92P`@\x85\x015a\nq\x81a\t\x91V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x8CW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x9CW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xB6Wa\n\xB6a\t\xB5V[a\n\xC9` `\x1F\x19`\x1F\x84\x01\x16\x01a\n\x0BV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n\xDDW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0B\x12W__\xFD[\x855a\x0B\x1D\x81a\t\x91V[\x94P` \x86\x015\x93P`@\x86\x015a\x0B4\x81a\t\x91V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0BeW__\xFD[Pa\x0Bna\t\xE2V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x93W__\xFD[Pa\x0B\x9Ca\t\xE2V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xB6W__\xFD[\x81Qa\x07\xA5\x81a\t\x91V[_` \x82\x84\x03\x12\x15a\x0B\xD1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0C\x10W\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[_` \x82\x84\x03\x12\x15a\x0C&W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\xA5W__\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\xFE\xA2dipfsX\"\x12 #\xC6\x9F\x1F4j\x13~\xBA\xBD\x05\x83\xE0\xB1\x05\x8FN\xC6a;\x1Cg\xB1 >\x01O\x1B\xB3\x9BCgdsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct StrategySlippageArgs { uint256 amountOutMin; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct StrategySlippageArgs { + #[allow(missing_docs)] + pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: StrategySlippageArgs) -> Self { + (value.amountOutMin,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for StrategySlippageArgs { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { amountOutMin: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for StrategySlippageArgs { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for StrategySlippageArgs { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for StrategySlippageArgs { + const NAME: &'static str = "StrategySlippageArgs"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "StrategySlippageArgs(uint256 amountOutMin)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) + .0 + .to_vec() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for StrategySlippageArgs { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.amountOutMin, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.amountOutMin, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. +```solidity +event TokenOutput(address tokenReceived, uint256 amountOut); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct TokenOutput { + #[allow(missing_docs)] + pub tokenReceived: alloy::sol_types::private::Address, + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for TokenOutput { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + tokenReceived: data.0, + amountOut: data.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.tokenReceived, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountOut), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 TokenOutput { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&TokenOutput> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(address _bedrockStrategy, address _pellStrategy); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _bedrockStrategy: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _pellStrategy: alloy::sol_types::private::Address, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._bedrockStrategy, value._pellStrategy) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _bedrockStrategy: tuple.0, + _pellStrategy: 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> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._bedrockStrategy, + ), + ::tokenize( + &self._pellStrategy, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `bedrockStrategy()` and selector `0x231710a5`. +```solidity +function bedrockStrategy() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct bedrockStrategyCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`bedrockStrategy()`](bedrockStrategyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct bedrockStrategyReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: bedrockStrategyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for bedrockStrategyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: bedrockStrategyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for bedrockStrategyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for bedrockStrategyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "bedrockStrategy()"; + const SELECTOR: [u8; 4] = [35u8, 23u8, 16u8, 165u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: bedrockStrategyReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: bedrockStrategyReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. +```solidity +function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub message: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ); + #[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, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.message) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + message: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageCall { + 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, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; + const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.message, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. +```solidity +function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amount, address recipient, StrategySlippageArgs memory args) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub args: ::RustType, + } + ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Address, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { + (value.tokenSent, value.amount, value.recipient, value.args) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amount: tuple.1, + recipient: tuple.2, + args: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageWithSlippageArgsReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageWithSlippageArgsReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; + const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.args, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `pellStrategy()` and selector `0xa6aa9cc0`. +```solidity +function pellStrategy() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct pellStrategyCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`pellStrategy()`](pellStrategyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct pellStrategyReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: pellStrategyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for pellStrategyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: pellStrategyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for pellStrategyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for pellStrategyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "pellStrategy()"; + const SELECTOR: [u8; 4] = [166u8, 170u8, 156u8, 192u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: pellStrategyReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: pellStrategyReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`PellBedrockStrategy`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum PellBedrockStrategyCalls { + #[allow(missing_docs)] + bedrockStrategy(bedrockStrategyCall), + #[allow(missing_docs)] + handleGatewayMessage(handleGatewayMessageCall), + #[allow(missing_docs)] + handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), + #[allow(missing_docs)] + pellStrategy(pellStrategyCall), + } + #[automatically_derived] + impl PellBedrockStrategyCalls { + /// 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]] = &[ + [35u8, 23u8, 16u8, 165u8], + [80u8, 99u8, 76u8, 14u8], + [127u8, 129u8, 79u8, 53u8], + [166u8, 170u8, 156u8, 192u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for PellBedrockStrategyCalls { + const NAME: &'static str = "PellBedrockStrategyCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 4usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::bedrockStrategy(_) => { + ::SELECTOR + } + Self::handleGatewayMessage(_) => { + ::SELECTOR + } + Self::handleGatewayMessageWithSlippageArgs(_) => { + ::SELECTOR + } + Self::pellStrategy(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn bedrockStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellBedrockStrategyCalls::bedrockStrategy) + } + bedrockStrategy + }, + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellBedrockStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + PellBedrockStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + { + fn pellStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellBedrockStrategyCalls::pellStrategy) + } + pellStrategy + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn bedrockStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellBedrockStrategyCalls::bedrockStrategy) + } + bedrockStrategy + }, + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellBedrockStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + PellBedrockStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + { + fn pellStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellBedrockStrategyCalls::pellStrategy) + } + pellStrategy + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::bedrockStrategy(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::handleGatewayMessage(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::pellStrategy(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::bedrockStrategy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::handleGatewayMessage(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::pellStrategy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`PellBedrockStrategy`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum PellBedrockStrategyEvents { + #[allow(missing_docs)] + TokenOutput(TokenOutput), + } + #[automatically_derived] + impl PellBedrockStrategyEvents { + /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for PellBedrockStrategyEvents { + const NAME: &'static str = "PellBedrockStrategyEvents"; + const COUNT: usize = 1usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::TokenOutput) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 PellBedrockStrategyEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`PellBedrockStrategy`](self) contract instance. + +See the [wrapper's documentation](`PellBedrockStrategyInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> PellBedrockStrategyInstance { + PellBedrockStrategyInstance::::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: alloy_contract::private::Network, + >( + provider: P, + _bedrockStrategy: alloy::sol_types::private::Address, + _pellStrategy: alloy::sol_types::private::Address, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + PellBedrockStrategyInstance::< + P, + N, + >::deploy(provider, _bedrockStrategy, _pellStrategy) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + _bedrockStrategy: alloy::sol_types::private::Address, + _pellStrategy: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + PellBedrockStrategyInstance::< + P, + N, + >::deploy_builder(provider, _bedrockStrategy, _pellStrategy) + } + /**A [`PellBedrockStrategy`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`PellBedrockStrategy`](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 PellBedrockStrategyInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for PellBedrockStrategyInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("PellBedrockStrategyInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > PellBedrockStrategyInstance { + /**Creates a new wrapper around an on-chain [`PellBedrockStrategy`](self) contract instance. + +See the [wrapper's documentation](`PellBedrockStrategyInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + _bedrockStrategy: alloy::sol_types::private::Address, + _pellStrategy: alloy::sol_types::private::Address, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder( + provider, + _bedrockStrategy, + _pellStrategy, + ); + 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, + _bedrockStrategy: alloy::sol_types::private::Address, + _pellStrategy: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + _bedrockStrategy, + _pellStrategy, + }, + )[..], + ] + .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 PellBedrockStrategyInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> PellBedrockStrategyInstance { + PellBedrockStrategyInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > PellBedrockStrategyInstance { + /// 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( + &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 [`bedrockStrategy`] function. + pub fn bedrockStrategy( + &self, + ) -> alloy_contract::SolCallBuilder<&P, bedrockStrategyCall, N> { + self.call_builder(&bedrockStrategyCall) + } + ///Creates a new call builder for the [`handleGatewayMessage`] function. + pub fn handleGatewayMessage( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + message: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { + self.call_builder( + &handleGatewayMessageCall { + tokenSent, + amountIn, + recipient, + message, + }, + ) + } + ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. + pub fn handleGatewayMessageWithSlippageArgs( + &self, + tokenSent: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + args: ::RustType, + ) -> alloy_contract::SolCallBuilder< + &P, + handleGatewayMessageWithSlippageArgsCall, + N, + > { + self.call_builder( + &handleGatewayMessageWithSlippageArgsCall { + tokenSent, + amount, + recipient, + args, + }, + ) + } + ///Creates a new call builder for the [`pellStrategy`] function. + pub fn pellStrategy( + &self, + ) -> alloy_contract::SolCallBuilder<&P, pellStrategyCall, N> { + self.call_builder(&pellStrategyCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > PellBedrockStrategyInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`TokenOutput`] event. + pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/pell_solv_lst_strategy.rs b/crates/bindings/src/pell_solv_lst_strategy.rs new file mode 100644 index 000000000..ee489b92c --- /dev/null +++ b/crates/bindings/src/pell_solv_lst_strategy.rs @@ -0,0 +1,1808 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface PellSolvLSTStrategy { + struct StrategySlippageArgs { + uint256 amountOutMin; + } + + event TokenOutput(address tokenReceived, uint256 amountOut); + + constructor(address _solvLSTStrategy, address _pellStrategy); + + function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; + function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amount, address recipient, StrategySlippageArgs memory args) external; + function pellStrategy() external view returns (address); + function solvLSTStrategy() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_solvLSTStrategy", + "type": "address", + "internalType": "contract SolvLSTStrategy" + }, + { + "name": "_pellStrategy", + "type": "address", + "internalType": "contract PellStrategy" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessage", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "message", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessageWithSlippageArgs", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "args", + "type": "tuple", + "internalType": "struct StrategySlippageArgs", + "components": [ + { + "name": "amountOutMin", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "pellStrategy", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract PellStrategy" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "solvLSTStrategy", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract SolvLSTStrategy" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "TokenOutput", + "inputs": [ + { + "name": "tokenReceived", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "amountOut", + "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 PellSolvLSTStrategy { + use super::*; + use alloy::sol_types as 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\r 8\x03\x80a\r \x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CJa\0\xD6_9_\x81\x81`{\x01R\x81\x81a\x03u\x01Ra\x03\xF5\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0CJ_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cPcL\x0E\x14a\0NW\x80c\x7F\x81O5\x14a\0cW\x80c\xA6\xAA\x9C\xC0\x14a\0vW\x80c\xF2#L\xF9\x14a\0\xC6W[__\xFD[a\0aa\0\\6`\x04a\t\xD0V[a\0\xEDV[\0[a\0aa\0q6`\x04a\n\x92V[a\x01\x17V[a\0\x9D\x7F\0\0\0\0\0\0\0\0\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\x9D\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 ;\xBE\xA4\0\nXD\x11.v'\xBB\xE5\xECgi\x01\x98\xF0\xDF\xD9,\xA6^&\r\xB6\x93\x85\x0Bf\xA8dsolcC\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\x80cPcL\x0E\x14a\0NW\x80c\x7F\x81O5\x14a\0cW\x80c\xA6\xAA\x9C\xC0\x14a\0vW\x80c\xF2#L\xF9\x14a\0\xC6W[__\xFD[a\0aa\0\\6`\x04a\t\xD0V[a\0\xEDV[\0[a\0aa\0q6`\x04a\n\x92V[a\x01\x17V[a\0\x9D\x7F\0\0\0\0\0\0\0\0\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\x9D\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 ;\xBE\xA4\0\nXD\x11.v'\xBB\xE5\xECgi\x01\x98\xF0\xDF\xD9,\xA6^&\r\xB6\x93\x85\x0Bf\xA8dsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct StrategySlippageArgs { uint256 amountOutMin; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct StrategySlippageArgs { + #[allow(missing_docs)] + pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: StrategySlippageArgs) -> Self { + (value.amountOutMin,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for StrategySlippageArgs { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { amountOutMin: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for StrategySlippageArgs { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for StrategySlippageArgs { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for StrategySlippageArgs { + const NAME: &'static str = "StrategySlippageArgs"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "StrategySlippageArgs(uint256 amountOutMin)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) + .0 + .to_vec() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for StrategySlippageArgs { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.amountOutMin, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.amountOutMin, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. +```solidity +event TokenOutput(address tokenReceived, uint256 amountOut); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct TokenOutput { + #[allow(missing_docs)] + pub tokenReceived: alloy::sol_types::private::Address, + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for TokenOutput { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + tokenReceived: data.0, + amountOut: data.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.tokenReceived, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountOut), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 TokenOutput { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&TokenOutput> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(address _solvLSTStrategy, address _pellStrategy); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _solvLSTStrategy: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _pellStrategy: alloy::sol_types::private::Address, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._solvLSTStrategy, value._pellStrategy) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _solvLSTStrategy: tuple.0, + _pellStrategy: 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> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._solvLSTStrategy, + ), + ::tokenize( + &self._pellStrategy, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. +```solidity +function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub message: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ); + #[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, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.message) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + message: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageCall { + 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, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; + const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.message, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. +```solidity +function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amount, address recipient, StrategySlippageArgs memory args) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub args: ::RustType, + } + ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Address, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { + (value.tokenSent, value.amount, value.recipient, value.args) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amount: tuple.1, + recipient: tuple.2, + args: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageWithSlippageArgsReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageWithSlippageArgsReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; + const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.args, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `pellStrategy()` and selector `0xa6aa9cc0`. +```solidity +function pellStrategy() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct pellStrategyCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`pellStrategy()`](pellStrategyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct pellStrategyReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: pellStrategyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for pellStrategyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: pellStrategyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for pellStrategyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for pellStrategyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "pellStrategy()"; + const SELECTOR: [u8; 4] = [166u8, 170u8, 156u8, 192u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: pellStrategyReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: pellStrategyReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `solvLSTStrategy()` and selector `0xf2234cf9`. +```solidity +function solvLSTStrategy() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct solvLSTStrategyCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`solvLSTStrategy()`](solvLSTStrategyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct solvLSTStrategyReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: solvLSTStrategyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for solvLSTStrategyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: solvLSTStrategyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for solvLSTStrategyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for solvLSTStrategyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "solvLSTStrategy()"; + const SELECTOR: [u8; 4] = [242u8, 35u8, 76u8, 249u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: solvLSTStrategyReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: solvLSTStrategyReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`PellSolvLSTStrategy`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum PellSolvLSTStrategyCalls { + #[allow(missing_docs)] + handleGatewayMessage(handleGatewayMessageCall), + #[allow(missing_docs)] + handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), + #[allow(missing_docs)] + pellStrategy(pellStrategyCall), + #[allow(missing_docs)] + solvLSTStrategy(solvLSTStrategyCall), + } + #[automatically_derived] + impl PellSolvLSTStrategyCalls { + /// 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, 99u8, 76u8, 14u8], + [127u8, 129u8, 79u8, 53u8], + [166u8, 170u8, 156u8, 192u8], + [242u8, 35u8, 76u8, 249u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for PellSolvLSTStrategyCalls { + const NAME: &'static str = "PellSolvLSTStrategyCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 4usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::handleGatewayMessage(_) => { + ::SELECTOR + } + Self::handleGatewayMessageWithSlippageArgs(_) => { + ::SELECTOR + } + Self::pellStrategy(_) => { + ::SELECTOR + } + Self::solvLSTStrategy(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellSolvLSTStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + PellSolvLSTStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + { + fn pellStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellSolvLSTStrategyCalls::pellStrategy) + } + pellStrategy + }, + { + fn solvLSTStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellSolvLSTStrategyCalls::solvLSTStrategy) + } + solvLSTStrategy + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellSolvLSTStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + PellSolvLSTStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + { + fn pellStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellSolvLSTStrategyCalls::pellStrategy) + } + pellStrategy + }, + { + fn solvLSTStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellSolvLSTStrategyCalls::solvLSTStrategy) + } + solvLSTStrategy + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::handleGatewayMessage(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::pellStrategy(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::solvLSTStrategy(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::handleGatewayMessage(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::pellStrategy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::solvLSTStrategy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`PellSolvLSTStrategy`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum PellSolvLSTStrategyEvents { + #[allow(missing_docs)] + TokenOutput(TokenOutput), + } + #[automatically_derived] + impl PellSolvLSTStrategyEvents { + /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for PellSolvLSTStrategyEvents { + const NAME: &'static str = "PellSolvLSTStrategyEvents"; + const COUNT: usize = 1usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::TokenOutput) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 PellSolvLSTStrategyEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`PellSolvLSTStrategy`](self) contract instance. + +See the [wrapper's documentation](`PellSolvLSTStrategyInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> PellSolvLSTStrategyInstance { + PellSolvLSTStrategyInstance::::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: alloy_contract::private::Network, + >( + provider: P, + _solvLSTStrategy: alloy::sol_types::private::Address, + _pellStrategy: alloy::sol_types::private::Address, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + PellSolvLSTStrategyInstance::< + P, + N, + >::deploy(provider, _solvLSTStrategy, _pellStrategy) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + _solvLSTStrategy: alloy::sol_types::private::Address, + _pellStrategy: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + PellSolvLSTStrategyInstance::< + P, + N, + >::deploy_builder(provider, _solvLSTStrategy, _pellStrategy) + } + /**A [`PellSolvLSTStrategy`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`PellSolvLSTStrategy`](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 PellSolvLSTStrategyInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for PellSolvLSTStrategyInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("PellSolvLSTStrategyInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > PellSolvLSTStrategyInstance { + /**Creates a new wrapper around an on-chain [`PellSolvLSTStrategy`](self) contract instance. + +See the [wrapper's documentation](`PellSolvLSTStrategyInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + _solvLSTStrategy: alloy::sol_types::private::Address, + _pellStrategy: alloy::sol_types::private::Address, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder( + provider, + _solvLSTStrategy, + _pellStrategy, + ); + 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, + _solvLSTStrategy: alloy::sol_types::private::Address, + _pellStrategy: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + _solvLSTStrategy, + _pellStrategy, + }, + )[..], + ] + .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 PellSolvLSTStrategyInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> PellSolvLSTStrategyInstance { + PellSolvLSTStrategyInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > PellSolvLSTStrategyInstance { + /// 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( + &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 [`handleGatewayMessage`] function. + pub fn handleGatewayMessage( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + message: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { + self.call_builder( + &handleGatewayMessageCall { + tokenSent, + amountIn, + recipient, + message, + }, + ) + } + ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. + pub fn handleGatewayMessageWithSlippageArgs( + &self, + tokenSent: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + args: ::RustType, + ) -> alloy_contract::SolCallBuilder< + &P, + handleGatewayMessageWithSlippageArgsCall, + N, + > { + self.call_builder( + &handleGatewayMessageWithSlippageArgsCall { + tokenSent, + amount, + recipient, + args, + }, + ) + } + ///Creates a new call builder for the [`pellStrategy`] function. + pub fn pellStrategy( + &self, + ) -> alloy_contract::SolCallBuilder<&P, pellStrategyCall, N> { + self.call_builder(&pellStrategyCall) + } + ///Creates a new call builder for the [`solvLSTStrategy`] function. + pub fn solvLSTStrategy( + &self, + ) -> alloy_contract::SolCallBuilder<&P, solvLSTStrategyCall, N> { + self.call_builder(&solvLSTStrategyCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > PellSolvLSTStrategyInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`TokenOutput`] event. + pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/pell_strategy.rs b/crates/bindings/src/pell_strategy.rs new file mode 100644 index 000000000..9f5fb32ef --- /dev/null +++ b/crates/bindings/src/pell_strategy.rs @@ -0,0 +1,2032 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface PellStrategy { + struct StrategySlippageArgs { + uint256 amountOutMin; + } + + event TokenOutput(address tokenReceived, uint256 amountOut); + + constructor(address _pellStrategyManager, address _pellStrategy); + + function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; + function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; + function pellStrategy() external view returns (address); + function pellStrategyManager() external view returns (address); + function stakerStrategyShares(address recipient) external view returns (uint256); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_pellStrategyManager", + "type": "address", + "internalType": "contract IPellStrategyManager" + }, + { + "name": "_pellStrategy", + "type": "address", + "internalType": "contract IPellStrategy" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessage", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "message", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessageWithSlippageArgs", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "args", + "type": "tuple", + "internalType": "struct StrategySlippageArgs", + "components": [ + { + "name": "amountOutMin", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "pellStrategy", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IPellStrategy" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "pellStrategyManager", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IPellStrategyManager" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "stakerStrategyShares", + "inputs": [ + { + "name": "recipient", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "TokenOutput", + "inputs": [ + { + "name": "tokenReceived", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "amountOut", + "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 PellStrategy { + use super::*; + use alloy::sol_types as 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\x0C\xF58\x03\x80a\x0C\xF5\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\x1Ea\0\xD7_9_\x81\x81`\xBB\x01R\x81\x81a\x01\x98\x01Ra\x02\xDB\x01R_\x81\x81a\x01\x07\x01R\x81\x81a\x01\xC2\x01R\x81\x81a\x02q\x01Ra\x03\x14\x01Ra\x0C\x1E_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0dW_5`\xE0\x1C\x80c\x7F\x81O5\x11a\0MW\x80c\x7F\x81O5\x14a\0\xA3W\x80c\xA6\xAA\x9C\xC0\x14a\0\xB6W\x80c\xC9F\x1AD\x14a\x01\x02W__\xFD[\x80cPcL\x0E\x14a\0hW\x80ct\xD1E\xB7\x14a\0}W[__\xFD[a\0{a\0v6`\x04a\t\xAAV[a\x01)V[\0[a\0\x90a\0\x8B6`\x04a\nlV[a\x01SV[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0{a\0\xB16`\x04a\n\x87V[a\x023V[a\0\xDD\x7F\0\0\0\0\0\0\0\0\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\0\x9AV[a\0\xDD\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01>\x91\x90a\x0B\x0BV[\x90Pa\x01L\x85\x85\x85\x84a\x023V[PPPPPV[`@Q\x7Fz~\r\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\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\x7F\0\0\0\0\0\0\0\0\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`$\x83\x01R_\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\x90\x91\x16\x90cz~\r\x92\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\tW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02-\x91\x90a\x0B/V[\x92\x91PPV[a\x02Us\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x043V[a\x02\x96s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\xF7V[`@Q\x7F\xE4hB\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\x83\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\x81\x16`$\x83\x01R\x85\x81\x16`D\x83\x01R`d\x82\x01\x85\x90R_\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\x90\x91\x16\x90c\xE4hB\xB7\x90`\x84\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\\W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x80\x91\x90a\x0B/V[\x82Q\x90\x91P\x81\x10\x15a\x03\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q_\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xF1\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xF2V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05kW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x8F\x91\x90a\x0B/V[a\x05\x99\x91\x90a\x0BFV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xF1\x90\x85\x90\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\x90`d\x01a\x04\x8DV[_a\x06S\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\x07\x02\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\xFDW\x80\x80` \x01\x90Q\x81\x01\x90a\x06q\x91\x90a\x0B~V[a\x06\xFDW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[PPPV[``a\x07\x10\x84\x84_\x85a\x07\x1AV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xACW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08*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\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x03\xEAV[__\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\x08R\x91\x90a\x0B\x9DV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x8CW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x91V[``\x91P[P\x91P\x91Pa\x08\xA1\x82\x82\x86a\x08\xACV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xBBWP\x81a\x07\x13V[\x82Q\x15a\x08\xCBW\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\xEA\x91\x90a\x0B\xB3V[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\t W__\xFD[PV[\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\tsWa\tsa\t#V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xA2Wa\t\xA2a\t#V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xBDW__\xFD[\x845a\t\xC8\x81a\x08\xFFV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xDF\x81a\x08\xFFV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xFAW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\nW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n$Wa\n$a\t#V[a\n7` `\x1F\x19`\x1F\x84\x01\x16\x01a\tyV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nKW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[_` \x82\x84\x03\x12\x15a\n|W__\xFD[\x815a\x07\x13\x81a\x08\xFFV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x9BW__\xFD[\x855a\n\xA6\x81a\x08\xFFV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xBD\x81a\x08\xFFV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xEEW__\xFD[Pa\n\xF7a\tPV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x1CW__\xFD[Pa\x0B%a\tPV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B?W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02-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[_` \x82\x84\x03\x12\x15a\x0B\x8EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x13W__\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\xFE\xA2dipfsX\"\x12 1\xA9_\tS$\x80\xC4eD\\\xF1\xA5F\x84\x08w?\xBD\x88\xEC\xC5\xCAl\x9C\xCA\x82\xDE\xCAb4\x08dsolcC\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\0dW_5`\xE0\x1C\x80c\x7F\x81O5\x11a\0MW\x80c\x7F\x81O5\x14a\0\xA3W\x80c\xA6\xAA\x9C\xC0\x14a\0\xB6W\x80c\xC9F\x1AD\x14a\x01\x02W__\xFD[\x80cPcL\x0E\x14a\0hW\x80ct\xD1E\xB7\x14a\0}W[__\xFD[a\0{a\0v6`\x04a\t\xAAV[a\x01)V[\0[a\0\x90a\0\x8B6`\x04a\nlV[a\x01SV[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0{a\0\xB16`\x04a\n\x87V[a\x023V[a\0\xDD\x7F\0\0\0\0\0\0\0\0\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\0\x9AV[a\0\xDD\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01>\x91\x90a\x0B\x0BV[\x90Pa\x01L\x85\x85\x85\x84a\x023V[PPPPPV[`@Q\x7Fz~\r\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\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\x7F\0\0\0\0\0\0\0\0\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`$\x83\x01R_\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\x90\x91\x16\x90cz~\r\x92\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\tW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02-\x91\x90a\x0B/V[\x92\x91PPV[a\x02Us\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x043V[a\x02\x96s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\xF7V[`@Q\x7F\xE4hB\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\x83\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\x81\x16`$\x83\x01R\x85\x81\x16`D\x83\x01R`d\x82\x01\x85\x90R_\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\x90\x91\x16\x90c\xE4hB\xB7\x90`\x84\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\\W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x80\x91\x90a\x0B/V[\x82Q\x90\x91P\x81\x10\x15a\x03\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q_\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xF1\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xF2V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05kW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x8F\x91\x90a\x0B/V[a\x05\x99\x91\x90a\x0BFV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xF1\x90\x85\x90\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\x90`d\x01a\x04\x8DV[_a\x06S\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\x07\x02\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\xFDW\x80\x80` \x01\x90Q\x81\x01\x90a\x06q\x91\x90a\x0B~V[a\x06\xFDW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[PPPV[``a\x07\x10\x84\x84_\x85a\x07\x1AV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xACW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08*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\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x03\xEAV[__\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\x08R\x91\x90a\x0B\x9DV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x8CW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x91V[``\x91P[P\x91P\x91Pa\x08\xA1\x82\x82\x86a\x08\xACV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xBBWP\x81a\x07\x13V[\x82Q\x15a\x08\xCBW\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\xEA\x91\x90a\x0B\xB3V[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\t W__\xFD[PV[\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\tsWa\tsa\t#V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xA2Wa\t\xA2a\t#V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xBDW__\xFD[\x845a\t\xC8\x81a\x08\xFFV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xDF\x81a\x08\xFFV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xFAW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\nW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n$Wa\n$a\t#V[a\n7` `\x1F\x19`\x1F\x84\x01\x16\x01a\tyV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nKW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[_` \x82\x84\x03\x12\x15a\n|W__\xFD[\x815a\x07\x13\x81a\x08\xFFV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x9BW__\xFD[\x855a\n\xA6\x81a\x08\xFFV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xBD\x81a\x08\xFFV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xEEW__\xFD[Pa\n\xF7a\tPV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x1CW__\xFD[Pa\x0B%a\tPV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B?W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02-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[_` \x82\x84\x03\x12\x15a\x0B\x8EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x13W__\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\xFE\xA2dipfsX\"\x12 1\xA9_\tS$\x80\xC4eD\\\xF1\xA5F\x84\x08w?\xBD\x88\xEC\xC5\xCAl\x9C\xCA\x82\xDE\xCAb4\x08dsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct StrategySlippageArgs { uint256 amountOutMin; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct StrategySlippageArgs { + #[allow(missing_docs)] + pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: StrategySlippageArgs) -> Self { + (value.amountOutMin,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for StrategySlippageArgs { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { amountOutMin: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for StrategySlippageArgs { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for StrategySlippageArgs { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for StrategySlippageArgs { + const NAME: &'static str = "StrategySlippageArgs"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "StrategySlippageArgs(uint256 amountOutMin)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) + .0 + .to_vec() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for StrategySlippageArgs { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.amountOutMin, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.amountOutMin, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. +```solidity +event TokenOutput(address tokenReceived, uint256 amountOut); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct TokenOutput { + #[allow(missing_docs)] + pub tokenReceived: alloy::sol_types::private::Address, + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for TokenOutput { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + tokenReceived: data.0, + amountOut: data.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.tokenReceived, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountOut), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 TokenOutput { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&TokenOutput> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(address _pellStrategyManager, address _pellStrategy); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _pellStrategyManager: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _pellStrategy: alloy::sol_types::private::Address, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._pellStrategyManager, value._pellStrategy) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _pellStrategyManager: tuple.0, + _pellStrategy: 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> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._pellStrategyManager, + ), + ::tokenize( + &self._pellStrategy, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. +```solidity +function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub message: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ); + #[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, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.message) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + message: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageCall { + 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, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; + const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.message, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. +```solidity +function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub args: ::RustType, + } + ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Address, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.args) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + args: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageWithSlippageArgsReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageWithSlippageArgsReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; + const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.args, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `pellStrategy()` and selector `0xa6aa9cc0`. +```solidity +function pellStrategy() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct pellStrategyCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`pellStrategy()`](pellStrategyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct pellStrategyReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: pellStrategyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for pellStrategyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: pellStrategyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for pellStrategyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for pellStrategyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "pellStrategy()"; + const SELECTOR: [u8; 4] = [166u8, 170u8, 156u8, 192u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: pellStrategyReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: pellStrategyReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `pellStrategyManager()` and selector `0xc9461a44`. +```solidity +function pellStrategyManager() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct pellStrategyManagerCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`pellStrategyManager()`](pellStrategyManagerCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct pellStrategyManagerReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: pellStrategyManagerCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for pellStrategyManagerCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: pellStrategyManagerReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for pellStrategyManagerReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for pellStrategyManagerCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "pellStrategyManager()"; + const SELECTOR: [u8; 4] = [201u8, 70u8, 26u8, 68u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: pellStrategyManagerReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: pellStrategyManagerReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `stakerStrategyShares(address)` and selector `0x74d145b7`. +```solidity +function stakerStrategyShares(address recipient) external view returns (uint256); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct stakerStrategySharesCall { + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`stakerStrategyShares(address)`](stakerStrategySharesCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct stakerStrategySharesReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: stakerStrategySharesCall) -> Self { + (value.recipient,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for stakerStrategySharesCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { recipient: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: stakerStrategySharesReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for stakerStrategySharesReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for stakerStrategySharesCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "stakerStrategyShares(address)"; + const SELECTOR: [u8; 4] = [116u8, 209u8, 69u8, 183u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.recipient, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: stakerStrategySharesReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: stakerStrategySharesReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`PellStrategy`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum PellStrategyCalls { + #[allow(missing_docs)] + handleGatewayMessage(handleGatewayMessageCall), + #[allow(missing_docs)] + handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), + #[allow(missing_docs)] + pellStrategy(pellStrategyCall), + #[allow(missing_docs)] + pellStrategyManager(pellStrategyManagerCall), + #[allow(missing_docs)] + stakerStrategyShares(stakerStrategySharesCall), + } + #[automatically_derived] + impl PellStrategyCalls { + /// 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, 99u8, 76u8, 14u8], + [116u8, 209u8, 69u8, 183u8], + [127u8, 129u8, 79u8, 53u8], + [166u8, 170u8, 156u8, 192u8], + [201u8, 70u8, 26u8, 68u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for PellStrategyCalls { + const NAME: &'static str = "PellStrategyCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 5usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::handleGatewayMessage(_) => { + ::SELECTOR + } + Self::handleGatewayMessageWithSlippageArgs(_) => { + ::SELECTOR + } + Self::pellStrategy(_) => { + ::SELECTOR + } + Self::pellStrategyManager(_) => { + ::SELECTOR + } + Self::stakerStrategyShares(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn stakerStrategyShares( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellStrategyCalls::stakerStrategyShares) + } + stakerStrategyShares + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellStrategyCalls::handleGatewayMessageWithSlippageArgs) + } + handleGatewayMessageWithSlippageArgs + }, + { + fn pellStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellStrategyCalls::pellStrategy) + } + pellStrategy + }, + { + fn pellStrategyManager( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellStrategyCalls::pellStrategyManager) + } + pellStrategyManager + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn stakerStrategyShares( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellStrategyCalls::stakerStrategyShares) + } + stakerStrategyShares + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellStrategyCalls::handleGatewayMessageWithSlippageArgs) + } + handleGatewayMessageWithSlippageArgs + }, + { + fn pellStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellStrategyCalls::pellStrategy) + } + pellStrategy + }, + { + fn pellStrategyManager( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellStrategyCalls::pellStrategyManager) + } + pellStrategyManager + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::handleGatewayMessage(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::pellStrategy(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::pellStrategyManager(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::stakerStrategyShares(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::handleGatewayMessage(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::pellStrategy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::pellStrategyManager(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::stakerStrategyShares(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`PellStrategy`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum PellStrategyEvents { + #[allow(missing_docs)] + TokenOutput(TokenOutput), + } + #[automatically_derived] + impl PellStrategyEvents { + /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for PellStrategyEvents { + const NAME: &'static str = "PellStrategyEvents"; + const COUNT: usize = 1usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::TokenOutput) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 PellStrategyEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`PellStrategy`](self) contract instance. + +See the [wrapper's documentation](`PellStrategyInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> PellStrategyInstance { + PellStrategyInstance::::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: alloy_contract::private::Network, + >( + provider: P, + _pellStrategyManager: alloy::sol_types::private::Address, + _pellStrategy: alloy::sol_types::private::Address, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + PellStrategyInstance::< + P, + N, + >::deploy(provider, _pellStrategyManager, _pellStrategy) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + _pellStrategyManager: alloy::sol_types::private::Address, + _pellStrategy: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + PellStrategyInstance::< + P, + N, + >::deploy_builder(provider, _pellStrategyManager, _pellStrategy) + } + /**A [`PellStrategy`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`PellStrategy`](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 PellStrategyInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for PellStrategyInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("PellStrategyInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > PellStrategyInstance { + /**Creates a new wrapper around an on-chain [`PellStrategy`](self) contract instance. + +See the [wrapper's documentation](`PellStrategyInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + _pellStrategyManager: alloy::sol_types::private::Address, + _pellStrategy: alloy::sol_types::private::Address, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder( + provider, + _pellStrategyManager, + _pellStrategy, + ); + 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, + _pellStrategyManager: alloy::sol_types::private::Address, + _pellStrategy: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + _pellStrategyManager, + _pellStrategy, + }, + )[..], + ] + .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 PellStrategyInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> PellStrategyInstance { + PellStrategyInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > PellStrategyInstance { + /// 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( + &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 [`handleGatewayMessage`] function. + pub fn handleGatewayMessage( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + message: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { + self.call_builder( + &handleGatewayMessageCall { + tokenSent, + amountIn, + recipient, + message, + }, + ) + } + ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. + pub fn handleGatewayMessageWithSlippageArgs( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + args: ::RustType, + ) -> alloy_contract::SolCallBuilder< + &P, + handleGatewayMessageWithSlippageArgsCall, + N, + > { + self.call_builder( + &handleGatewayMessageWithSlippageArgsCall { + tokenSent, + amountIn, + recipient, + args, + }, + ) + } + ///Creates a new call builder for the [`pellStrategy`] function. + pub fn pellStrategy( + &self, + ) -> alloy_contract::SolCallBuilder<&P, pellStrategyCall, N> { + self.call_builder(&pellStrategyCall) + } + ///Creates a new call builder for the [`pellStrategyManager`] function. + pub fn pellStrategyManager( + &self, + ) -> alloy_contract::SolCallBuilder<&P, pellStrategyManagerCall, N> { + self.call_builder(&pellStrategyManagerCall) + } + ///Creates a new call builder for the [`stakerStrategyShares`] function. + pub fn stakerStrategyShares( + &self, + recipient: alloy::sol_types::private::Address, + ) -> alloy_contract::SolCallBuilder<&P, stakerStrategySharesCall, N> { + self.call_builder( + &stakerStrategySharesCall { + recipient, + }, + ) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > PellStrategyInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`TokenOutput`] event. + pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/pell_strategy_forked.rs b/crates/bindings/src/pell_strategy_forked.rs new file mode 100644 index 000000000..9d7df05ac --- /dev/null +++ b/crates/bindings/src/pell_strategy_forked.rs @@ -0,0 +1,7991 @@ +///Module containing a contract's types and functions. +/** + +```solidity +library StdInvariant { + struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } + struct FuzzInterface { address addr; string[] artifacts; } + struct FuzzSelector { address addr; bytes4[] selectors; } +} +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod StdInvariant { + use super::*; + use alloy::sol_types as alloy_sol_types; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzArtifactSelector { + #[allow(missing_docs)] + pub artifact: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub selectors: alloy::sol_types::private::Vec< + 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 as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::String, + alloy::sol_types::private::Vec>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzArtifactSelector) -> Self { + (value.artifact, value.selectors) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzArtifactSelector { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + artifact: tuple.0, + selectors: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzArtifactSelector { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.artifact, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.selectors), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzArtifactSelector { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzArtifactSelector { + const NAME: &'static str = "FuzzArtifactSelector"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzArtifactSelector(string artifact,bytes4[] selectors)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.artifact, + ) + .0, + , + > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzArtifactSelector { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.artifact, + ) + + , + > as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.selectors, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.artifact, + out, + ); + , + > as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.selectors, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzInterface { address addr; string[] artifacts; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzInterface { + #[allow(missing_docs)] + pub addr: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub artifacts: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzInterface) -> Self { + (value.addr, value.artifacts) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzInterface { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + addr: tuple.0, + artifacts: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzInterface { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzInterface { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.addr, + ), + as alloy_sol_types::SolType>::tokenize(&self.artifacts), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzInterface { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzInterface { + const NAME: &'static str = "FuzzInterface"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzInterface(address addr,string[] artifacts)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.addr, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzInterface { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.addr, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.artifacts, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.addr, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.artifacts, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzSelector { address addr; bytes4[] selectors; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzSelector { + #[allow(missing_docs)] + pub addr: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub selectors: alloy::sol_types::private::Vec< + 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 as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Vec>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzSelector) -> Self { + (value.addr, value.selectors) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzSelector { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + addr: tuple.0, + selectors: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzSelector { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzSelector { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.addr, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.selectors), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzSelector { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzSelector { + const NAME: &'static str = "FuzzSelector"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzSelector(address addr,bytes4[] selectors)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.addr, + ) + .0, + , + > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzSelector { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.addr, + ) + + , + > as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.selectors, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.addr, + out, + ); + , + > as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.selectors, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. + +See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> StdInvariantInstance { + StdInvariantInstance::::new(address, provider) + } + /**A [`StdInvariant`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`StdInvariant`](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 StdInvariantInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for StdInvariantInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("StdInvariantInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. + +See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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 StdInvariantInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> StdInvariantInstance { + StdInvariantInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} +/** + +Generated by the following Solidity interface... +```solidity +library StdInvariant { + struct FuzzArtifactSelector { + string artifact; + bytes4[] selectors; + } + struct FuzzInterface { + address addr; + string[] artifacts; + } + struct FuzzSelector { + address addr; + bytes4[] selectors; + } +} + +interface PellStrategyForked { + event log(string); + event log_address(address); + event log_array(uint256[] val); + event log_array(int256[] val); + event log_array(address[] val); + event log_bytes(bytes); + event log_bytes32(bytes32); + event log_int(int256); + event log_named_address(string key, address val); + event log_named_array(string key, uint256[] val); + event log_named_array(string key, int256[] val); + event log_named_array(string key, address[] val); + event log_named_bytes(string key, bytes val); + event log_named_bytes32(string key, bytes32 val); + event log_named_decimal_int(string key, int256 val, uint256 decimals); + event log_named_decimal_uint(string key, uint256 val, uint256 decimals); + event log_named_int(string key, int256 val); + event log_named_string(string key, string val); + event log_named_uint(string key, uint256 val); + event log_string(string); + event log_uint(uint256); + event logs(bytes); + + function IS_TEST() external view returns (bool); + function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); + function excludeContracts() external view returns (address[] memory excludedContracts_); + function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); + function excludeSenders() external view returns (address[] memory excludedSenders_); + function failed() external view returns (bool); + function setUp() external; + function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; + function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); + function targetArtifacts() external view returns (string[] memory targetedArtifacts_); + function targetContracts() external view returns (address[] memory targetedContracts_); + function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); + function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); + function targetSenders() external view returns (address[] memory targetedSenders_); + function testPellStrategy() external; + function token() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "IS_TEST", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeArtifacts", + "inputs": [], + "outputs": [ + { + "name": "excludedArtifacts_", + "type": "string[]", + "internalType": "string[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeContracts", + "inputs": [], + "outputs": [ + { + "name": "excludedContracts_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeSelectors", + "inputs": [], + "outputs": [ + { + "name": "excludedSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzSelector[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeSenders", + "inputs": [], + "outputs": [ + { + "name": "excludedSenders_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "failed", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "setUp", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "simulateForkAndTransfer", + "inputs": [ + { + "name": "forkAtBlock", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "sender", + "type": "address", + "internalType": "address" + }, + { + "name": "receiver", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "targetArtifactSelectors", + "inputs": [], + "outputs": [ + { + "name": "targetedArtifactSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzArtifactSelector[]", + "components": [ + { + "name": "artifact", + "type": "string", + "internalType": "string" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetArtifacts", + "inputs": [], + "outputs": [ + { + "name": "targetedArtifacts_", + "type": "string[]", + "internalType": "string[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetContracts", + "inputs": [], + "outputs": [ + { + "name": "targetedContracts_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetInterfaces", + "inputs": [], + "outputs": [ + { + "name": "targetedInterfaces_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzInterface[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "artifacts", + "type": "string[]", + "internalType": "string[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetSelectors", + "inputs": [], + "outputs": [ + { + "name": "targetedSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzSelector[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetSenders", + "inputs": [], + "outputs": [ + { + "name": "targetedSenders_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "testPellStrategy", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "token", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IERC20" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "log", + "inputs": [ + { + "name": "", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_address", + "inputs": [ + { + "name": "", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "uint256[]", + "indexed": false, + "internalType": "uint256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "int256[]", + "indexed": false, + "internalType": "int256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "address[]", + "indexed": false, + "internalType": "address[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_bytes", + "inputs": [ + { + "name": "", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_bytes32", + "inputs": [ + { + "name": "", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_int", + "inputs": [ + { + "name": "", + "type": "int256", + "indexed": false, + "internalType": "int256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_address", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256[]", + "indexed": false, + "internalType": "uint256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256[]", + "indexed": false, + "internalType": "int256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "address[]", + "indexed": false, + "internalType": "address[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_bytes", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_bytes32", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_decimal_int", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256", + "indexed": false, + "internalType": "int256" + }, + { + "name": "decimals", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_decimal_uint", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "decimals", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_int", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256", + "indexed": false, + "internalType": "int256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_string", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_uint", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_string", + "inputs": [ + { + "name": "", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_uint", + "inputs": [ + { + "name": "", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "logs", + "inputs": [ + { + "name": "", + "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 PellStrategyForked { + use super::*; + use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15`+W__\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16t\xBB\xA2\xEF\x94]R^<#\x14a\x01=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07`W__\xFD[PZ\xF1\x15\x80\x15a\x07rW=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x07\xF9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\x1D\x91\x90a\x15\x82V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\xB5W__\xFD[PZ\xF1\x15\x80\x15a\x08\xC7W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t$W__\xFD[PZ\xF1\x15\x80\x15a\t6W=__>=_\xFD[PP`@Q\x7Ft\xD1E\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\x81R`\x01`\x04\x82\x01Ra\t\xD9\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x91Pct\xD1E\xB7\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\t\xA7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\xCB\x91\x90a\x15\xA8V[g\r\xE0\xB6\xB3\xA7d\0\0a\x11\tV[PV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\n\x1C\x90a\x151V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\nH\x90a\x151V[\x80\x15a\n\x93W\x80`\x1F\x10a\njWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\x93V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\nvW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\t\xFFV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0B\x92W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0B?W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\n\xCAV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\x95W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0CBW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0B\xCDV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\x0C\xED\x90a\x151V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\x19\x90a\x151V[\x80\x15a\rdW\x80`\x1F\x10a\r;Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rdV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\rGW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xD0V[`\x08T_\x90`\xFF\x16\x15a\r\x8FWP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\x1DW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0EA\x91\x90a\x15\xA8V[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0FNW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x0Fu\x91\x90\x81\x01\x90a\x15\xECV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0F\x93\x92\x91\x90a\x16\xA0V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0F\xAFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xD3\x91\x90a\x15\xA8V[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10LW__\xFD[PZ\xF1\x15\x80\x15a\x10^W=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10\xDEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\x02\x91\x90a\x15\x82V[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x11rW__\xFD[PZ\xFA\x15\x80\x15a\x11\x84W=__>=_\xFD[PPPPPPV[a\x0C\xF5\x80a\x16\xC2\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x11\xE6W\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\x11\xB2V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x07W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x12\xEDW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x12\xD7\x84\x86Qa\x11\xF1V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x12\x9DV[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x12EV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x13eW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x13%V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x07W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x13\xBB`@\x88\x01\x82a\x11\xF1V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x13\xD6\x81\x83a\x13\x13V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x13\x95V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x07W`?\x19\x87\x86\x03\x01\x84Ra\x14/\x85\x83Qa\x11\xF1V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\x13V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x07W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x14\xB2`@\x87\x01\x82a\x13\x13V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14jV[\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\xEBW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x15\x03W__\xFD[\x845\x93Pa\x15\x13` \x86\x01a\x14\xC8V[\x92Pa\x15!`@\x86\x01a\x14\xC8V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x15EW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x15|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`\"`\x04R`$_\xFD[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x15\x92W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x15\xA1W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x15\xB8W__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x15\xFCW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\x12W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x16\"W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\x91\x90a\x0B\x0BV[\x90Pa\x01L\x85\x85\x85\x84a\x023V[PPPPPV[`@Q\x7Fz~\r\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\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\x7F\0\0\0\0\0\0\0\0\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`$\x83\x01R_\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\x90\x91\x16\x90cz~\r\x92\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\tW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02-\x91\x90a\x0B/V[\x92\x91PPV[a\x02Us\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x043V[a\x02\x96s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\xF7V[`@Q\x7F\xE4hB\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\x83\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\x81\x16`$\x83\x01R\x85\x81\x16`D\x83\x01R`d\x82\x01\x85\x90R_\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\x90\x91\x16\x90c\xE4hB\xB7\x90`\x84\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\\W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x80\x91\x90a\x0B/V[\x82Q\x90\x91P\x81\x10\x15a\x03\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q_\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xF1\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xF2V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05kW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x8F\x91\x90a\x0B/V[a\x05\x99\x91\x90a\x0BFV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xF1\x90\x85\x90\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\x90`d\x01a\x04\x8DV[_a\x06S\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\x07\x02\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\xFDW\x80\x80` \x01\x90Q\x81\x01\x90a\x06q\x91\x90a\x0B~V[a\x06\xFDW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[PPPV[``a\x07\x10\x84\x84_\x85a\x07\x1AV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xACW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08*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\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x03\xEAV[__\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\x08R\x91\x90a\x0B\x9DV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x8CW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x91V[``\x91P[P\x91P\x91Pa\x08\xA1\x82\x82\x86a\x08\xACV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xBBWP\x81a\x07\x13V[\x82Q\x15a\x08\xCBW\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\xEA\x91\x90a\x0B\xB3V[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\t W__\xFD[PV[\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\tsWa\tsa\t#V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xA2Wa\t\xA2a\t#V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xBDW__\xFD[\x845a\t\xC8\x81a\x08\xFFV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xDF\x81a\x08\xFFV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xFAW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\nW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n$Wa\n$a\t#V[a\n7` `\x1F\x19`\x1F\x84\x01\x16\x01a\tyV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nKW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[_` \x82\x84\x03\x12\x15a\n|W__\xFD[\x815a\x07\x13\x81a\x08\xFFV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x9BW__\xFD[\x855a\n\xA6\x81a\x08\xFFV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xBD\x81a\x08\xFFV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xEEW__\xFD[Pa\n\xF7a\tPV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x1CW__\xFD[Pa\x0B%a\tPV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B?W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02-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[_` \x82\x84\x03\x12\x15a\x0B\x8EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x13W__\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\xFE\xA2dipfsX\"\x12 1\xA9_\tS$\x80\xC4eD\\\xF1\xA5F\x84\x08w?\xBD\x88\xEC\xC5\xCAl\x9C\xCA\x82\xDE\xCAb4\x08dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 jdsU\xB5\xE9\xE4\x99\xC8\x0C^<#\x14a\x01=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07`W__\xFD[PZ\xF1\x15\x80\x15a\x07rW=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x07\xF9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\x1D\x91\x90a\x15\x82V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\xB5W__\xFD[PZ\xF1\x15\x80\x15a\x08\xC7W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t$W__\xFD[PZ\xF1\x15\x80\x15a\t6W=__>=_\xFD[PP`@Q\x7Ft\xD1E\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\x81R`\x01`\x04\x82\x01Ra\t\xD9\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x91Pct\xD1E\xB7\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\t\xA7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\xCB\x91\x90a\x15\xA8V[g\r\xE0\xB6\xB3\xA7d\0\0a\x11\tV[PV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\n\x1C\x90a\x151V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\nH\x90a\x151V[\x80\x15a\n\x93W\x80`\x1F\x10a\njWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\x93V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\nvW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\t\xFFV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0B\x92W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0B?W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\n\xCAV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\x95W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0CBW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0B\xCDV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\x0C\xED\x90a\x151V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\x19\x90a\x151V[\x80\x15a\rdW\x80`\x1F\x10a\r;Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rdV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\rGW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xD0V[`\x08T_\x90`\xFF\x16\x15a\r\x8FWP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\x1DW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0EA\x91\x90a\x15\xA8V[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0FNW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x0Fu\x91\x90\x81\x01\x90a\x15\xECV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0F\x93\x92\x91\x90a\x16\xA0V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0F\xAFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xD3\x91\x90a\x15\xA8V[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10LW__\xFD[PZ\xF1\x15\x80\x15a\x10^W=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10\xDEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\x02\x91\x90a\x15\x82V[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x11rW__\xFD[PZ\xFA\x15\x80\x15a\x11\x84W=__>=_\xFD[PPPPPPV[a\x0C\xF5\x80a\x16\xC2\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x11\xE6W\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\x11\xB2V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x07W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x12\xEDW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x12\xD7\x84\x86Qa\x11\xF1V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x12\x9DV[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x12EV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x13eW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x13%V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x07W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x13\xBB`@\x88\x01\x82a\x11\xF1V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x13\xD6\x81\x83a\x13\x13V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x13\x95V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x07W`?\x19\x87\x86\x03\x01\x84Ra\x14/\x85\x83Qa\x11\xF1V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\x13V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x07W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x14\xB2`@\x87\x01\x82a\x13\x13V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14jV[\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\xEBW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x15\x03W__\xFD[\x845\x93Pa\x15\x13` \x86\x01a\x14\xC8V[\x92Pa\x15!`@\x86\x01a\x14\xC8V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x15EW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x15|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`\"`\x04R`$_\xFD[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x15\x92W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x15\xA1W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x15\xB8W__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x15\xFCW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\x12W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x16\"W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\x91\x90a\x0B\x0BV[\x90Pa\x01L\x85\x85\x85\x84a\x023V[PPPPPV[`@Q\x7Fz~\r\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\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\x7F\0\0\0\0\0\0\0\0\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`$\x83\x01R_\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\x90\x91\x16\x90cz~\r\x92\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\tW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02-\x91\x90a\x0B/V[\x92\x91PPV[a\x02Us\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x043V[a\x02\x96s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\xF7V[`@Q\x7F\xE4hB\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\x83\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\x81\x16`$\x83\x01R\x85\x81\x16`D\x83\x01R`d\x82\x01\x85\x90R_\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\x90\x91\x16\x90c\xE4hB\xB7\x90`\x84\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\\W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x80\x91\x90a\x0B/V[\x82Q\x90\x91P\x81\x10\x15a\x03\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q_\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xF1\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xF2V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05kW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x8F\x91\x90a\x0B/V[a\x05\x99\x91\x90a\x0BFV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xF1\x90\x85\x90\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\x90`d\x01a\x04\x8DV[_a\x06S\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\x07\x02\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\xFDW\x80\x80` \x01\x90Q\x81\x01\x90a\x06q\x91\x90a\x0B~V[a\x06\xFDW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[PPPV[``a\x07\x10\x84\x84_\x85a\x07\x1AV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xACW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08*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\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x03\xEAV[__\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\x08R\x91\x90a\x0B\x9DV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x8CW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x91V[``\x91P[P\x91P\x91Pa\x08\xA1\x82\x82\x86a\x08\xACV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xBBWP\x81a\x07\x13V[\x82Q\x15a\x08\xCBW\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\xEA\x91\x90a\x0B\xB3V[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\t W__\xFD[PV[\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\tsWa\tsa\t#V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xA2Wa\t\xA2a\t#V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xBDW__\xFD[\x845a\t\xC8\x81a\x08\xFFV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xDF\x81a\x08\xFFV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xFAW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\nW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n$Wa\n$a\t#V[a\n7` `\x1F\x19`\x1F\x84\x01\x16\x01a\tyV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nKW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[_` \x82\x84\x03\x12\x15a\n|W__\xFD[\x815a\x07\x13\x81a\x08\xFFV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x9BW__\xFD[\x855a\n\xA6\x81a\x08\xFFV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xBD\x81a\x08\xFFV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xEEW__\xFD[Pa\n\xF7a\tPV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x1CW__\xFD[Pa\x0B%a\tPV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B?W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02-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[_` \x82\x84\x03\x12\x15a\x0B\x8EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x13W__\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\xFE\xA2dipfsX\"\x12 1\xA9_\tS$\x80\xC4eD\\\xF1\xA5F\x84\x08w?\xBD\x88\xEC\xC5\xCAl\x9C\xCA\x82\xDE\xCAb4\x08dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 jdsU\xB5\xE9\xE4\x99\xC8\x0C = (alloy::sol_types::sol_data::String,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log(string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, + 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, + 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. +```solidity +event log_address(address); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_address { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_address { + type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_address(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, + 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, + 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_address { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_address> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_address) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. +```solidity +event log_array(uint256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_0 { + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_0 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(uint256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, + 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, + 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_0 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_0> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. +```solidity +event log_array(int256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_1 { + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_1 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(int256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, + 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, + 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_1 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_1> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. +```solidity +event log_array(address[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_2 { + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_2 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(address[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, + 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, + 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_2 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_2> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. +```solidity +event log_bytes(bytes); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_bytes { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_bytes { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_bytes(bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, + 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, + 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_bytes { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_bytes> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. +```solidity +event log_bytes32(bytes32); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_bytes32 { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_bytes32 { + type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_bytes32(bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, + 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, + 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_bytes32 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_bytes32> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. +```solidity +event log_int(int256); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_int { + #[allow(missing_docs)] + pub _0: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_int { + type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_int(int256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, + 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, + 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. +```solidity +event log_named_address(string key, address val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_address { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_address { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Address, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_address(string,address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, + 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, + 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_address { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_address> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. +```solidity +event log_named_array(string key, uint256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_0 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_0 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, + 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, + 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_0 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_0> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. +```solidity +event log_named_array(string key, int256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_1 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_1 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,int256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, + 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, + 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_1 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_1> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. +```solidity +event log_named_array(string key, address[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_2 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_2 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,address[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, + 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, + 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_2 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_2> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. +```solidity +event log_named_bytes(string key, bytes val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_bytes { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_bytes { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Bytes, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, + 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, + 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_bytes { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_bytes> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. +```solidity +event log_named_bytes32(string key, bytes32 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_bytes32 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_bytes32 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::FixedBytes<32>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, + 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, + 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_bytes32 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. +```solidity +event log_named_decimal_int(string key, int256 val, uint256 decimals); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_decimal_int { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::I256, + #[allow(missing_docs)] + pub decimals: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_decimal_int { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Int<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, + 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, + 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + key: data.0, + val: data.1, + decimals: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + as alloy_sol_types::SolType>::tokenize(&self.decimals), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_decimal_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. +```solidity +event log_named_decimal_uint(string key, uint256 val, uint256 decimals); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_decimal_uint { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub decimals: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_decimal_uint { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, + 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, + 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + key: data.0, + val: data.1, + decimals: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + as alloy_sol_types::SolType>::tokenize(&self.decimals), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. +```solidity +event log_named_int(string key, int256 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_int { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_int { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Int<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_int(string,int256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, + 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, + 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. +```solidity +event log_named_string(string key, string val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_string { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::String, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_string { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::String, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_string(string,string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, + 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, + 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_string { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_string> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. +```solidity +event log_named_uint(string key, uint256 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_uint { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_uint { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, + 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, + 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. +```solidity +event log_string(string); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_string { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_string { + type DataTuple<'a> = (alloy::sol_types::sol_data::String,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_string(string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, + 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, + 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_string { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_string> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_string) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. +```solidity +event log_uint(uint256); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_uint { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_uint { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_uint(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, + 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, + 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. +```solidity +event logs(bytes); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct logs { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for logs { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "logs(bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, + 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, + 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 logs { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&logs> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &logs) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. +```solidity +function IS_TEST() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IS_TESTCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IS_TESTReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IS_TESTCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IS_TESTCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IS_TESTReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IS_TESTReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for IS_TESTCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "IS_TEST()"; + const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: IS_TESTReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: IS_TESTReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. +```solidity +function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeArtifactsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeArtifactsReturn { + #[allow(missing_docs)] + pub excludedArtifacts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeArtifactsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeArtifactsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeArtifactsReturn) -> Self { + (value.excludedArtifacts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeArtifactsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedArtifacts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeArtifactsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeArtifacts()"; + const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeArtifactsReturn = r.into(); + r.excludedArtifacts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeArtifactsReturn = r.into(); + r.excludedArtifacts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. +```solidity +function excludeContracts() external view returns (address[] memory excludedContracts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeContractsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeContractsReturn { + #[allow(missing_docs)] + pub excludedContracts_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeContractsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeContractsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeContractsReturn) -> Self { + (value.excludedContracts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeContractsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedContracts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeContractsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeContracts()"; + const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeContractsReturn = r.into(); + r.excludedContracts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeContractsReturn = r.into(); + r.excludedContracts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. +```solidity +function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSelectorsReturn { + #[allow(missing_docs)] + pub excludedSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSelectorsReturn) -> Self { + (value.excludedSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeSelectors()"; + const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeSelectorsReturn = r.into(); + r.excludedSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeSelectorsReturn = r.into(); + r.excludedSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. +```solidity +function excludeSenders() external view returns (address[] memory excludedSenders_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSendersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSendersReturn { + #[allow(missing_docs)] + pub excludedSenders_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: excludeSendersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for excludeSendersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSendersReturn) -> Self { + (value.excludedSenders_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSendersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { excludedSenders_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeSendersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeSenders()"; + const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeSendersReturn = r.into(); + r.excludedSenders_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeSendersReturn = r.into(); + r.excludedSenders_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `failed()` and selector `0xba414fa6`. +```solidity +function failed() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct failedCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`failed()`](failedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct failedReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: failedCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for failedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: failedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for failedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for failedCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "failed()"; + const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: failedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: failedReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `setUp()` and selector `0x0a9254e4`. +```solidity +function setUp() external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setUpCall; + ///Container type for the return parameters of the [`setUp()`](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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setUpCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setUpReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setUpReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setUpCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setUpReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setUp()"; + const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setUpReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. +```solidity +function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct simulateForkAndTransferCall { + #[allow(missing_docs)] + pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub sender: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct simulateForkAndTransferReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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::Uint<256>, + ); + #[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::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferCall) -> Self { + (value.forkAtBlock, value.sender, value.receiver, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for simulateForkAndTransferCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + forkAtBlock: tuple.0, + sender: tuple.1, + receiver: tuple.2, + amount: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for simulateForkAndTransferReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl simulateForkAndTransferReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for simulateForkAndTransferCall { + type Parameters<'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::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = simulateForkAndTransferReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; + const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), + ::tokenize( + &self.sender, + ), + ::tokenize( + &self.receiver, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + simulateForkAndTransferReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. +```solidity +function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactSelectorsReturn { + #[allow(missing_docs)] + pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactSelectorsReturn) -> Self { + (value.targetedArtifactSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedArtifactSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetArtifactSelectors()"; + const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetArtifacts()` and selector `0x85226c81`. +```solidity +function targetArtifacts() external view returns (string[] memory targetedArtifacts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactsReturn { + #[allow(missing_docs)] + pub targetedArtifacts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetArtifactsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsReturn) -> Self { + (value.targetedArtifacts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedArtifacts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetArtifactsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetArtifacts()"; + const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetContracts()` and selector `0x3f7286f4`. +```solidity +function targetContracts() external view returns (address[] memory targetedContracts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetContractsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetContractsReturn { + #[allow(missing_docs)] + pub targetedContracts_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetContractsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetContractsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetContractsReturn) -> Self { + (value.targetedContracts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetContractsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedContracts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetContractsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetContracts()"; + const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetContractsReturn = r.into(); + r.targetedContracts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetContractsReturn = r.into(); + r.targetedContracts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. +```solidity +function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetInterfacesCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetInterfacesReturn { + #[allow(missing_docs)] + pub targetedInterfaces_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetInterfacesCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetInterfacesCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetInterfacesReturn) -> Self { + (value.targetedInterfaces_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetInterfacesReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedInterfaces_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetInterfacesCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetInterfaces()"; + const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetSelectors()` and selector `0x916a17c6`. +```solidity +function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSelectorsReturn { + #[allow(missing_docs)] + pub targetedSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetSelectorsReturn) -> Self { + (value.targetedSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetSelectors()"; + const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. +```solidity +function targetSenders() external view returns (address[] memory targetedSenders_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSendersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSendersReturn { + #[allow(missing_docs)] + pub targetedSenders_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSendersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersReturn) -> Self { + (value.targetedSenders_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSendersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { targetedSenders_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetSendersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetSenders()"; + const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetSendersReturn = r.into(); + r.targetedSenders_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetSendersReturn = r.into(); + r.targetedSenders_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `testPellStrategy()` and selector `0x75b593aa`. +```solidity +function testPellStrategy() external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct testPellStrategyCall; + ///Container type for the return parameters of the [`testPellStrategy()`](testPellStrategyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct testPellStrategyReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: testPellStrategyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for testPellStrategyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: testPellStrategyReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for testPellStrategyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl testPellStrategyReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for testPellStrategyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = testPellStrategyReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "testPellStrategy()"; + const SELECTOR: [u8; 4] = [117u8, 181u8, 147u8, 170u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + testPellStrategyReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `token()` and selector `0xfc0c546a`. +```solidity +function token() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct tokenCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`token()`](tokenCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct tokenReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for tokenCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for tokenReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for tokenCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "token()"; + const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`PellStrategyForked`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum PellStrategyForkedCalls { + #[allow(missing_docs)] + IS_TEST(IS_TESTCall), + #[allow(missing_docs)] + excludeArtifacts(excludeArtifactsCall), + #[allow(missing_docs)] + excludeContracts(excludeContractsCall), + #[allow(missing_docs)] + excludeSelectors(excludeSelectorsCall), + #[allow(missing_docs)] + excludeSenders(excludeSendersCall), + #[allow(missing_docs)] + failed(failedCall), + #[allow(missing_docs)] + setUp(setUpCall), + #[allow(missing_docs)] + simulateForkAndTransfer(simulateForkAndTransferCall), + #[allow(missing_docs)] + targetArtifactSelectors(targetArtifactSelectorsCall), + #[allow(missing_docs)] + targetArtifacts(targetArtifactsCall), + #[allow(missing_docs)] + targetContracts(targetContractsCall), + #[allow(missing_docs)] + targetInterfaces(targetInterfacesCall), + #[allow(missing_docs)] + targetSelectors(targetSelectorsCall), + #[allow(missing_docs)] + targetSenders(targetSendersCall), + #[allow(missing_docs)] + testPellStrategy(testPellStrategyCall), + #[allow(missing_docs)] + token(tokenCall), + } + #[automatically_derived] + impl PellStrategyForkedCalls { + /// 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]] = &[ + [10u8, 146u8, 84u8, 228u8], + [30u8, 215u8, 131u8, 28u8], + [42u8, 222u8, 56u8, 128u8], + [62u8, 94u8, 60u8, 35u8], + [63u8, 114u8, 134u8, 244u8], + [102u8, 217u8, 169u8, 160u8], + [117u8, 181u8, 147u8, 170u8], + [133u8, 34u8, 108u8, 129u8], + [145u8, 106u8, 23u8, 198u8], + [176u8, 70u8, 79u8, 220u8], + [181u8, 80u8, 138u8, 169u8], + [186u8, 65u8, 79u8, 166u8], + [226u8, 12u8, 159u8, 113u8], + [249u8, 206u8, 14u8, 90u8], + [250u8, 118u8, 38u8, 212u8], + [252u8, 12u8, 84u8, 106u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for PellStrategyForkedCalls { + const NAME: &'static str = "PellStrategyForkedCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 16usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::IS_TEST(_) => ::SELECTOR, + Self::excludeArtifacts(_) => { + ::SELECTOR + } + Self::excludeContracts(_) => { + ::SELECTOR + } + Self::excludeSelectors(_) => { + ::SELECTOR + } + Self::excludeSenders(_) => { + ::SELECTOR + } + Self::failed(_) => ::SELECTOR, + Self::setUp(_) => ::SELECTOR, + Self::simulateForkAndTransfer(_) => { + ::SELECTOR + } + Self::targetArtifactSelectors(_) => { + ::SELECTOR + } + Self::targetArtifacts(_) => { + ::SELECTOR + } + Self::targetContracts(_) => { + ::SELECTOR + } + Self::targetInterfaces(_) => { + ::SELECTOR + } + Self::targetSelectors(_) => { + ::SELECTOR + } + Self::targetSenders(_) => { + ::SELECTOR + } + Self::testPellStrategy(_) => { + ::SELECTOR + } + Self::token(_) => ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn setUp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(PellStrategyForkedCalls::setUp) + } + setUp + }, + { + fn excludeSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellStrategyForkedCalls::excludeSenders) + } + excludeSenders + }, + { + fn targetInterfaces( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellStrategyForkedCalls::targetInterfaces) + } + targetInterfaces + }, + { + fn targetSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellStrategyForkedCalls::targetSenders) + } + targetSenders + }, + { + fn targetContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellStrategyForkedCalls::targetContracts) + } + targetContracts + }, + { + fn targetArtifactSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellStrategyForkedCalls::targetArtifactSelectors) + } + targetArtifactSelectors + }, + { + fn testPellStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellStrategyForkedCalls::testPellStrategy) + } + testPellStrategy + }, + { + fn targetArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellStrategyForkedCalls::targetArtifacts) + } + targetArtifacts + }, + { + fn targetSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellStrategyForkedCalls::targetSelectors) + } + targetSelectors + }, + { + fn excludeSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellStrategyForkedCalls::excludeSelectors) + } + excludeSelectors + }, + { + fn excludeArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellStrategyForkedCalls::excludeArtifacts) + } + excludeArtifacts + }, + { + fn failed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(PellStrategyForkedCalls::failed) + } + failed + }, + { + fn excludeContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellStrategyForkedCalls::excludeContracts) + } + excludeContracts + }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(PellStrategyForkedCalls::simulateForkAndTransfer) + } + simulateForkAndTransfer + }, + { + fn IS_TEST( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(PellStrategyForkedCalls::IS_TEST) + } + IS_TEST + }, + { + fn token( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(PellStrategyForkedCalls::token) + } + token + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn setUp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellStrategyForkedCalls::setUp) + } + setUp + }, + { + fn excludeSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellStrategyForkedCalls::excludeSenders) + } + excludeSenders + }, + { + fn targetInterfaces( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellStrategyForkedCalls::targetInterfaces) + } + targetInterfaces + }, + { + fn targetSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellStrategyForkedCalls::targetSenders) + } + targetSenders + }, + { + fn targetContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellStrategyForkedCalls::targetContracts) + } + targetContracts + }, + { + fn targetArtifactSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellStrategyForkedCalls::targetArtifactSelectors) + } + targetArtifactSelectors + }, + { + fn testPellStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellStrategyForkedCalls::testPellStrategy) + } + testPellStrategy + }, + { + fn targetArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellStrategyForkedCalls::targetArtifacts) + } + targetArtifacts + }, + { + fn targetSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellStrategyForkedCalls::targetSelectors) + } + targetSelectors + }, + { + fn excludeSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellStrategyForkedCalls::excludeSelectors) + } + excludeSelectors + }, + { + fn excludeArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellStrategyForkedCalls::excludeArtifacts) + } + excludeArtifacts + }, + { + fn failed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellStrategyForkedCalls::failed) + } + failed + }, + { + fn excludeContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellStrategyForkedCalls::excludeContracts) + } + excludeContracts + }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellStrategyForkedCalls::simulateForkAndTransfer) + } + simulateForkAndTransfer + }, + { + fn IS_TEST( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellStrategyForkedCalls::IS_TEST) + } + IS_TEST + }, + { + fn token( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(PellStrategyForkedCalls::token) + } + token + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::IS_TEST(inner) => { + ::abi_encoded_size(inner) + } + Self::excludeArtifacts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeContracts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeSenders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::failed(inner) => { + ::abi_encoded_size(inner) + } + Self::setUp(inner) => { + ::abi_encoded_size(inner) + } + Self::simulateForkAndTransfer(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetArtifactSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetArtifacts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetContracts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetInterfaces(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetSenders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::testPellStrategy(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::token(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::IS_TEST(inner) => { + ::abi_encode_raw(inner, out) + } + Self::excludeArtifacts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeContracts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeSenders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::failed(inner) => { + ::abi_encode_raw(inner, out) + } + Self::setUp(inner) => { + ::abi_encode_raw(inner, out) + } + Self::simulateForkAndTransfer(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetArtifactSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetArtifacts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetContracts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetInterfaces(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetSenders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::testPellStrategy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::token(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + ///Container for all the [`PellStrategyForked`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum PellStrategyForkedEvents { + #[allow(missing_docs)] + log(log), + #[allow(missing_docs)] + log_address(log_address), + #[allow(missing_docs)] + log_array_0(log_array_0), + #[allow(missing_docs)] + log_array_1(log_array_1), + #[allow(missing_docs)] + log_array_2(log_array_2), + #[allow(missing_docs)] + log_bytes(log_bytes), + #[allow(missing_docs)] + log_bytes32(log_bytes32), + #[allow(missing_docs)] + log_int(log_int), + #[allow(missing_docs)] + log_named_address(log_named_address), + #[allow(missing_docs)] + log_named_array_0(log_named_array_0), + #[allow(missing_docs)] + log_named_array_1(log_named_array_1), + #[allow(missing_docs)] + log_named_array_2(log_named_array_2), + #[allow(missing_docs)] + log_named_bytes(log_named_bytes), + #[allow(missing_docs)] + log_named_bytes32(log_named_bytes32), + #[allow(missing_docs)] + log_named_decimal_int(log_named_decimal_int), + #[allow(missing_docs)] + log_named_decimal_uint(log_named_decimal_uint), + #[allow(missing_docs)] + log_named_int(log_named_int), + #[allow(missing_docs)] + log_named_string(log_named_string), + #[allow(missing_docs)] + log_named_uint(log_named_uint), + #[allow(missing_docs)] + log_string(log_string), + #[allow(missing_docs)] + log_uint(log_uint), + #[allow(missing_docs)] + logs(logs), + } + #[automatically_derived] + impl PellStrategyForkedEvents { + /// 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]] = &[ + [ + 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, + 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, + 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, + ], + [ + 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, + 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, + 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, + ], + [ + 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, + 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, + 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, + ], + [ + 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, + 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, + 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, + ], + [ + 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, + 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, + 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, + ], + [ + 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, + 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, + 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, + ], + [ + 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, + 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, + 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, + ], + [ + 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, + 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, + 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, + ], + [ + 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, + 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, + 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, + ], + [ + 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, + 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, + 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, + ], + [ + 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, + 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, + 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, + ], + [ + 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, + 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, + 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, + ], + [ + 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, + 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, + 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, + ], + [ + 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, + 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, + 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, + ], + [ + 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, + 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, + 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, + ], + [ + 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, + 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, + 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, + ], + [ + 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, + 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, + 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, + ], + [ + 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, + 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, + 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, + ], + [ + 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, + 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, + 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, + ], + [ + 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, + 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, + 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, + ], + [ + 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, + 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, + 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, + ], + [ + 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, + 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, + 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for PellStrategyForkedEvents { + const NAME: &'static str = "PellStrategyForkedEvents"; + const COUNT: usize = 22usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_address) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_0) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_1) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_2) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_bytes) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_bytes32) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log_int) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_address) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_0) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_1) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_2) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_bytes) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_bytes32) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_decimal_int) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_decimal_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_int) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_string) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_string) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::logs) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 PellStrategyForkedEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::log(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_address(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_0(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_1(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_2(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_bytes(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_address(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_0(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_1(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_2(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_bytes(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_decimal_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_decimal_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_string(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_string(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::logs(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::log(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_address(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_0(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_1(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_2(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_bytes(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_address(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_0(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_1(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_2(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_bytes(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_decimal_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_decimal_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_string(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_string(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::logs(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`PellStrategyForked`](self) contract instance. + +See the [wrapper's documentation](`PellStrategyForkedInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> PellStrategyForkedInstance { + PellStrategyForkedInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + PellStrategyForkedInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + PellStrategyForkedInstance::::deploy_builder(provider) + } + /**A [`PellStrategyForked`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`PellStrategyForked`](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 PellStrategyForkedInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for PellStrategyForkedInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("PellStrategyForkedInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > PellStrategyForkedInstance { + /**Creates a new wrapper around an on-chain [`PellStrategyForked`](self) contract instance. + +See the [wrapper's documentation](`PellStrategyForkedInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 PellStrategyForkedInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> PellStrategyForkedInstance { + PellStrategyForkedInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > PellStrategyForkedInstance { + /// 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( + &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 [`IS_TEST`] function. + pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { + self.call_builder(&IS_TESTCall) + } + ///Creates a new call builder for the [`excludeArtifacts`] function. + pub fn excludeArtifacts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { + self.call_builder(&excludeArtifactsCall) + } + ///Creates a new call builder for the [`excludeContracts`] function. + pub fn excludeContracts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { + self.call_builder(&excludeContractsCall) + } + ///Creates a new call builder for the [`excludeSelectors`] function. + pub fn excludeSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { + self.call_builder(&excludeSelectorsCall) + } + ///Creates a new call builder for the [`excludeSenders`] function. + pub fn excludeSenders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { + self.call_builder(&excludeSendersCall) + } + ///Creates a new call builder for the [`failed`] function. + pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { + self.call_builder(&failedCall) + } + ///Creates a new call builder for the [`setUp`] function. + pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { + self.call_builder(&setUpCall) + } + ///Creates a new call builder for the [`simulateForkAndTransfer`] function. + pub fn simulateForkAndTransfer( + &self, + forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + sender: alloy::sol_types::private::Address, + receiver: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { + self.call_builder( + &simulateForkAndTransferCall { + forkAtBlock, + sender, + receiver, + amount, + }, + ) + } + ///Creates a new call builder for the [`targetArtifactSelectors`] function. + pub fn targetArtifactSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { + self.call_builder(&targetArtifactSelectorsCall) + } + ///Creates a new call builder for the [`targetArtifacts`] function. + pub fn targetArtifacts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { + self.call_builder(&targetArtifactsCall) + } + ///Creates a new call builder for the [`targetContracts`] function. + pub fn targetContracts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { + self.call_builder(&targetContractsCall) + } + ///Creates a new call builder for the [`targetInterfaces`] function. + pub fn targetInterfaces( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { + self.call_builder(&targetInterfacesCall) + } + ///Creates a new call builder for the [`targetSelectors`] function. + pub fn targetSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { + self.call_builder(&targetSelectorsCall) + } + ///Creates a new call builder for the [`targetSenders`] function. + pub fn targetSenders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { + self.call_builder(&targetSendersCall) + } + ///Creates a new call builder for the [`testPellStrategy`] function. + pub fn testPellStrategy( + &self, + ) -> alloy_contract::SolCallBuilder<&P, testPellStrategyCall, N> { + self.call_builder(&testPellStrategyCall) + } + ///Creates a new call builder for the [`token`] function. + pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { + self.call_builder(&tokenCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > PellStrategyForkedInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`log`] event. + pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_address`] event. + pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_0`] event. + pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_1`] event. + pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_2`] event. + pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_bytes`] event. + pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_bytes32`] event. + pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_int`] event. + pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_address`] event. + pub fn log_named_address_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_address, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_0`] event. + pub fn log_named_array_0_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_0, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_1`] event. + pub fn log_named_array_1_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_1, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_2`] event. + pub fn log_named_array_2_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_2, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_bytes`] event. + pub fn log_named_bytes_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_bytes, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_bytes32`] event. + pub fn log_named_bytes32_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_bytes32, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_decimal_int`] event. + pub fn log_named_decimal_int_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_decimal_uint`] event. + pub fn log_named_decimal_uint_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_int`] event. + pub fn log_named_int_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_string`] event. + pub fn log_named_string_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_string, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_uint`] event. + pub fn log_named_uint_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_string`] event. + pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_uint`] event. + pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`logs`] event. + pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/relay_utils.rs b/crates/bindings/src/relay_utils.rs new file mode 100644 index 000000000..38fa26fe8 --- /dev/null +++ b/crates/bindings/src/relay_utils.rs @@ -0,0 +1,218 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface RelayUtils {} +``` + +...which was generated by the following JSON ABI: +```json +[] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod RelayUtils { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220a931e155e8aef315bb51684c34bf3038ee4dd45e934c7d5e2b881d667c983ebd64736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`U`2`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`&WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \xA91\xE1U\xE8\xAE\xF3\x15\xBBQhL4\xBF08\xEEM\xD4^\x93L}^+\x88\x1Df|\x98>\xBDdsolcC\0\x08\x1C\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220a931e155e8aef315bb51684c34bf3038ee4dd45e934c7d5e2b881d667c983ebd64736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \xA91\xE1U\xE8\xAE\xF3\x15\xBBQhL4\xBF08\xEEM\xD4^\x93L}^+\x88\x1Df|\x98>\xBDdsolcC\0\x08\x1C\x003", + ); + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`RelayUtils`](self) contract instance. + +See the [wrapper's documentation](`RelayUtilsInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> RelayUtilsInstance { + RelayUtilsInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + RelayUtilsInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + RelayUtilsInstance::::deploy_builder(provider) + } + /**A [`RelayUtils`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`RelayUtils`](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 RelayUtilsInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for RelayUtilsInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("RelayUtilsInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > RelayUtilsInstance { + /**Creates a new wrapper around an on-chain [`RelayUtils`](self) contract instance. + +See the [wrapper's documentation](`RelayUtilsInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 RelayUtilsInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> RelayUtilsInstance { + RelayUtilsInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > RelayUtilsInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > RelayUtilsInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/safe_erc20.rs b/crates/bindings/src/safe_erc20.rs new file mode 100644 index 000000000..b62a37084 --- /dev/null +++ b/crates/bindings/src/safe_erc20.rs @@ -0,0 +1,218 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface SafeERC20 {} +``` + +...which was generated by the following JSON ABI: +```json +[] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod SafeERC20 { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220d0c38f997d08a2de89d8e0d01283ef76295b0a6b3f9c5bb0e964306fb609e80764736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`U`2`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`&WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \xD0\xC3\x8F\x99}\x08\xA2\xDE\x89\xD8\xE0\xD0\x12\x83\xEFv)[\nk?\x9C[\xB0\xE9d0o\xB6\t\xE8\x07dsolcC\0\x08\x1C\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220d0c38f997d08a2de89d8e0d01283ef76295b0a6b3f9c5bb0e964306fb609e80764736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \xD0\xC3\x8F\x99}\x08\xA2\xDE\x89\xD8\xE0\xD0\x12\x83\xEFv)[\nk?\x9C[\xB0\xE9d0o\xB6\t\xE8\x07dsolcC\0\x08\x1C\x003", + ); + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`SafeERC20`](self) contract instance. + +See the [wrapper's documentation](`SafeERC20Instance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> SafeERC20Instance { + SafeERC20Instance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + SafeERC20Instance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + SafeERC20Instance::::deploy_builder(provider) + } + /**A [`SafeERC20`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`SafeERC20`](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 SafeERC20Instance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for SafeERC20Instance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("SafeERC20Instance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SafeERC20Instance { + /**Creates a new wrapper around an on-chain [`SafeERC20`](self) contract instance. + +See the [wrapper's documentation](`SafeERC20Instance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 SafeERC20Instance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> SafeERC20Instance { + SafeERC20Instance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SafeERC20Instance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SafeERC20Instance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/safe_math.rs b/crates/bindings/src/safe_math.rs new file mode 100644 index 000000000..f4fed5595 --- /dev/null +++ b/crates/bindings/src/safe_math.rs @@ -0,0 +1,218 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface SafeMath {} +``` + +...which was generated by the following JSON ABI: +```json +[] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod SafeMath { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122058f09f5e12a9aa85fd6612b43f5ccd4644b79e031c89718212d843d4ae286e0364736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`U`2`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`&WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 X\xF0\x9F^\x12\xA9\xAA\x85\xFDf\x12\xB4?\\\xCDFD\xB7\x9E\x03\x1C\x89q\x82\x12\xD8C\xD4\xAE(n\x03dsolcC\0\x08\x1C\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122058f09f5e12a9aa85fd6612b43f5ccd4644b79e031c89718212d843d4ae286e0364736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 X\xF0\x9F^\x12\xA9\xAA\x85\xFDf\x12\xB4?\\\xCDFD\xB7\x9E\x03\x1C\x89q\x82\x12\xD8C\xD4\xAE(n\x03dsolcC\0\x08\x1C\x003", + ); + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`SafeMath`](self) contract instance. + +See the [wrapper's documentation](`SafeMathInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> SafeMathInstance { + SafeMathInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + SafeMathInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + SafeMathInstance::::deploy_builder(provider) + } + /**A [`SafeMath`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`SafeMath`](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 SafeMathInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for SafeMathInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("SafeMathInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SafeMathInstance { + /**Creates a new wrapper around an on-chain [`SafeMath`](self) contract instance. + +See the [wrapper's documentation](`SafeMathInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 SafeMathInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> SafeMathInstance { + SafeMathInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SafeMathInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SafeMathInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/seg_wit_utils.rs b/crates/bindings/src/seg_wit_utils.rs new file mode 100644 index 000000000..cc356c6b8 --- /dev/null +++ b/crates/bindings/src/seg_wit_utils.rs @@ -0,0 +1,723 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface SegWitUtils { + function COINBASE_WITNESS_PK_SCRIPT_LENGTH() external view returns (uint256); + function WITNESS_MAGIC_BYTES() external view returns (bytes6); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "COINBASE_WITNESS_PK_SCRIPT_LENGTH", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "WITNESS_MAGIC_BYTES", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bytes6", + "internalType": "bytes6" + } + ], + "stateMutability": "view" + } +] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod SegWitUtils { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x60e6610033600b8282823980515f1a607314602757634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610603c575f3560e01c8063c6cd9637146040578063e0e2748a14605a575b5f5ffd5b6047602681565b6040519081526020015b60405180910390f35b60807f6a24aa21a9ed000000000000000000000000000000000000000000000000000081565b6040517fffffffffffff00000000000000000000000000000000000000000000000000009091168152602001605156fea2646970667358221220bf3526a08adc2baa9cf339210d5dbbca5e3aa2c5555bc6027a5ea95bf97eed5a64736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`\xE6a\x003`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`'WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R`\x046\x10` = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: COINBASE_WITNESS_PK_SCRIPT_LENGTHCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for COINBASE_WITNESS_PK_SCRIPT_LENGTHCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: COINBASE_WITNESS_PK_SCRIPT_LENGTHReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for COINBASE_WITNESS_PK_SCRIPT_LENGTHReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for COINBASE_WITNESS_PK_SCRIPT_LENGTHCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::primitives::aliases::U256; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "COINBASE_WITNESS_PK_SCRIPT_LENGTH()"; + const SELECTOR: [u8; 4] = [198u8, 205u8, 150u8, 55u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: COINBASE_WITNESS_PK_SCRIPT_LENGTHReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: COINBASE_WITNESS_PK_SCRIPT_LENGTHReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `WITNESS_MAGIC_BYTES()` and selector `0xe0e2748a`. +```solidity +function WITNESS_MAGIC_BYTES() external view returns (bytes6); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct WITNESS_MAGIC_BYTESCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`WITNESS_MAGIC_BYTES()`](WITNESS_MAGIC_BYTESCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct WITNESS_MAGIC_BYTESReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::FixedBytes<6>, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: WITNESS_MAGIC_BYTESCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for WITNESS_MAGIC_BYTESCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<6>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<6>,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: WITNESS_MAGIC_BYTESReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for WITNESS_MAGIC_BYTESReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for WITNESS_MAGIC_BYTESCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::FixedBytes<6>; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<6>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "WITNESS_MAGIC_BYTES()"; + const SELECTOR: [u8; 4] = [224u8, 226u8, 116u8, 138u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: WITNESS_MAGIC_BYTESReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: WITNESS_MAGIC_BYTESReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`SegWitUtils`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum SegWitUtilsCalls { + #[allow(missing_docs)] + COINBASE_WITNESS_PK_SCRIPT_LENGTH(COINBASE_WITNESS_PK_SCRIPT_LENGTHCall), + #[allow(missing_docs)] + WITNESS_MAGIC_BYTES(WITNESS_MAGIC_BYTESCall), + } + #[automatically_derived] + impl SegWitUtilsCalls { + /// 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]] = &[ + [198u8, 205u8, 150u8, 55u8], + [224u8, 226u8, 116u8, 138u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for SegWitUtilsCalls { + const NAME: &'static str = "SegWitUtilsCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 2usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::COINBASE_WITNESS_PK_SCRIPT_LENGTH(_) => { + ::SELECTOR + } + Self::WITNESS_MAGIC_BYTES(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn COINBASE_WITNESS_PK_SCRIPT_LENGTH( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SegWitUtilsCalls::COINBASE_WITNESS_PK_SCRIPT_LENGTH) + } + COINBASE_WITNESS_PK_SCRIPT_LENGTH + }, + { + fn WITNESS_MAGIC_BYTES( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SegWitUtilsCalls::WITNESS_MAGIC_BYTES) + } + WITNESS_MAGIC_BYTES + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn COINBASE_WITNESS_PK_SCRIPT_LENGTH( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegWitUtilsCalls::COINBASE_WITNESS_PK_SCRIPT_LENGTH) + } + COINBASE_WITNESS_PK_SCRIPT_LENGTH + }, + { + fn WITNESS_MAGIC_BYTES( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegWitUtilsCalls::WITNESS_MAGIC_BYTES) + } + WITNESS_MAGIC_BYTES + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::COINBASE_WITNESS_PK_SCRIPT_LENGTH(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::WITNESS_MAGIC_BYTES(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::COINBASE_WITNESS_PK_SCRIPT_LENGTH(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::WITNESS_MAGIC_BYTES(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`SegWitUtils`](self) contract instance. + +See the [wrapper's documentation](`SegWitUtilsInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> SegWitUtilsInstance { + SegWitUtilsInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + SegWitUtilsInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + SegWitUtilsInstance::::deploy_builder(provider) + } + /**A [`SegWitUtils`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`SegWitUtils`](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 SegWitUtilsInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for SegWitUtilsInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("SegWitUtilsInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SegWitUtilsInstance { + /**Creates a new wrapper around an on-chain [`SegWitUtils`](self) contract instance. + +See the [wrapper's documentation](`SegWitUtilsInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 SegWitUtilsInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> SegWitUtilsInstance { + SegWitUtilsInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SegWitUtilsInstance { + /// 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( + &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 [`COINBASE_WITNESS_PK_SCRIPT_LENGTH`] function. + pub fn COINBASE_WITNESS_PK_SCRIPT_LENGTH( + &self, + ) -> alloy_contract::SolCallBuilder< + &P, + COINBASE_WITNESS_PK_SCRIPT_LENGTHCall, + N, + > { + self.call_builder(&COINBASE_WITNESS_PK_SCRIPT_LENGTHCall) + } + ///Creates a new call builder for the [`WITNESS_MAGIC_BYTES`] function. + pub fn WITNESS_MAGIC_BYTES( + &self, + ) -> alloy_contract::SolCallBuilder<&P, WITNESS_MAGIC_BYTESCall, N> { + self.call_builder(&WITNESS_MAGIC_BYTESCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SegWitUtilsInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/fullrelayheaviestfromancestortest.rs b/crates/bindings/src/segment_bedrock_and_lst_strategy_forked.rs similarity index 56% rename from crates/bindings/src/fullrelayheaviestfromancestortest.rs rename to crates/bindings/src/segment_bedrock_and_lst_strategy_forked.rs index 28454e873..799733571 100644 --- a/crates/bindings/src/fullrelayheaviestfromancestortest.rs +++ b/crates/bindings/src/segment_bedrock_and_lst_strategy_forked.rs @@ -837,7 +837,7 @@ library StdInvariant { } } -interface FullRelayHeaviestFromAncestorTest { +interface SegmentBedrockAndLstStrategyForked { event log(string); event log_address(address); event log_array(uint256[] val); @@ -861,43 +861,29 @@ interface FullRelayHeaviestFromAncestorTest { event log_uint(uint256); event logs(bytes); - constructor(); - function IS_TEST() external view returns (bool); function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); function excludeContracts() external view returns (address[] memory excludedContracts_); function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); function excludeSenders() external view returns (address[] memory excludedSenders_); function failed() external view returns (bool); - function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); - function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); - function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); - function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); + function setUp() external; + function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); function targetArtifacts() external view returns (string[] memory targetedArtifacts_); function targetContracts() external view returns (address[] memory targetedContracts_); function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); function targetSenders() external view returns (address[] memory targetedSenders_); - function testDescendantLeftBelowAncestor() external; - function testDescendantRightBelowAncestor() external; - function testEqualWeightsReturnsLeft() external view; - function testLeftIsHeavier() external view; - function testRightIsHeavier() external view; - function testUnknownAncestor() external; - function testUnknownLeft() external; - function testUnknownRight() external; + function testSegmentBedrockStrategy() external; + function testSegmentSolvLstStrategy() external; + function token() external view returns (address); } ``` ...which was generated by the following JSON ABI: ```json [ - { - "type": "constructor", - "inputs": [], - "stateMutability": "nonpayable" - }, { "type": "function", "name": "IS_TEST", @@ -990,119 +976,38 @@ interface FullRelayHeaviestFromAncestorTest { }, { "type": "function", - "name": "getBlockHeights", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getDigestLes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes32[]", - "internalType": "bytes32[]" - } - ], - "stateMutability": "view" + "name": "setUp", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" }, { "type": "function", - "name": "getHeaderHexes", + "name": "simulateForkAndTransfer", "inputs": [ { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", + "name": "forkAtBlock", "type": "uint256", "internalType": "uint256" }, { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes[]", - "internalType": "bytes[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaders", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" + "name": "sender", + "type": "address", + "internalType": "address" }, { - "name": "from", - "type": "uint256", - "internalType": "uint256" + "name": "receiver", + "type": "address", + "internalType": "address" }, { - "name": "to", + "name": "amount", "type": "uint256", "internalType": "uint256" } ], - "outputs": [ - { - "name": "headers", - "type": "bytes", - "internalType": "bytes" - } - ], - "stateMutability": "view" + "outputs": [], + "stateMutability": "nonpayable" }, { "type": "function", @@ -1220,60 +1125,31 @@ interface FullRelayHeaviestFromAncestorTest { }, { "type": "function", - "name": "testDescendantLeftBelowAncestor", + "name": "testSegmentBedrockStrategy", "inputs": [], "outputs": [], "stateMutability": "nonpayable" }, { "type": "function", - "name": "testDescendantRightBelowAncestor", + "name": "testSegmentSolvLstStrategy", "inputs": [], "outputs": [], "stateMutability": "nonpayable" }, { "type": "function", - "name": "testEqualWeightsReturnsLeft", - "inputs": [], - "outputs": [], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testLeftIsHeavier", - "inputs": [], - "outputs": [], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testRightIsHeavier", + "name": "token", "inputs": [], - "outputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IERC20" + } + ], "stateMutability": "view" }, - { - "type": "function", - "name": "testUnknownAncestor", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testUnknownLeft", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testUnknownRight", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, { "type": "event", "name": "log", @@ -1647,28 +1523,28 @@ interface FullRelayHeaviestFromAncestorTest { clippy::style, clippy::empty_structs_with_brackets )] -pub mod FullRelayHeaviestFromAncestorTest { +pub mod SegmentBedrockAndLstStrategyForked { use super::*; use alloy::sol_types as alloy_sol_types; /// 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`@R`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15a\0,W__\xFD[P`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k42\xB0\xB22\xB99\x9759\xB7\xB7`\xA1\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k\x05\xCC\xEC\xAD\xCC\xAEm.e\xCD\x0C\xAF`\xA3\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x0F\x81R` \x01n\x0B\x99\xD9[\x99\\\xDA\\\xCB\x9A\x19ZY\xDA\x1D`\x8A\x1B\x81RP`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01q.genesis.digest_le`p\x1B\x81RP__Q` aa\xAA_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x16c\xD90\xA0\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\x13W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01:\x91\x90\x81\x01\x90a\r{V[\x90P_\x81\x86`@Q` \x01a\x01P\x92\x91\x90a\r\xD6V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Rc`\xF9\xBB\x11`\xE0\x1B\x82R\x91P_Q` aa\xAA_9_Q\x90_R\x90c`\xF9\xBB\x11\x90a\x01\x90\x90\x84\x90`\x04\x01a\x0EHV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xAAW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01\xD1\x91\x90\x81\x01\x90a\r{V[` \x90a\x01\xDE\x90\x82a\x0E\xDEV[Pa\x02u\x85` \x80Ta\x01\xF0\x90a\x0EZV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\x1C\x90a\x0EZV[\x80\x15a\x02gW\x80`\x1F\x10a\x02>Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02gV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02JW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x07\x81\x91PPV[a\x03\x0B\x85` \x80Ta\x02\x86\x90a\x0EZV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\xB2\x90a\x0EZV[\x80\x15a\x02\xFDW\x80`\x1F\x10a\x02\xD4Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02\xFDV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02\xE0W\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x08\0\x91PPV[a\x03\xA1\x85` \x80Ta\x03\x1C\x90a\x0EZV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03H\x90a\x0EZV[\x80\x15a\x03\x93W\x80`\x1F\x10a\x03jWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\x93V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03vW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x08s\x91PPV[`@Qa\x03\xAD\x90a\x0B\xE2V[a\x03\xB9\x93\x92\x91\x90a\x0F\x98V[`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03\xD2W=__>=_\xFD[P`\x1F`\x01a\x01\0\n\x81T\x81`\x01`\x01`\xA0\x1B\x03\x02\x19\x16\x90\x83`\x01`\x01`\xA0\x1B\x03\x16\x02\x17\x90UPPPPPPPa\x04.`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01d1\xB40\xB4\xB7`\xD9\x1B\x81RP_`\x08a\x08\xA7` \x1B` \x1CV[\x80Qa\x04B\x91`\"\x91` \x90\x91\x01\x90a\x0B\xEFV[Pa\x04~`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01q.genesis.digest_le`p\x1B\x81RP` \x80Ta\x03\x1C\x90a\x0EZV[`!U`@\x80Q\x80\x82\x01\x90\x91R`\x05\x81Rd1\xB40\xB4\xB7`\xD9\x1B` \x82\x01Ra\x04\xA9\x90_`\x08a\x08\xE4V[\x80Qa\x04\xBD\x91`#\x91` \x90\x91\x01\x90a\x0C8V[P_a\x04\xEE`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01d1\xB40\xB4\xB7`\xD9\x1B\x81RP_`\x08a\t\x13` \x1B` \x1CV[\x90P\x80a\x05&`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01d1\xB40\xB4\xB7`\xD9\x1B\x81RP`\x08\x80`\x01a\x05!\x91\x90a\x0F\xD0V[a\t\x13V[`@Q` \x01a\x057\x92\x91\x90a\x0F\xE3V[`@Q` \x81\x83\x03\x03\x81R\x90`@R`$\x90\x81a\x05T\x91\x90a\x0E\xDEV[P\x80a\x05\x91`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01q\x05\xCD\xEEN\r\x0C-\xCB\xE6\xA6\xC6F\xC6f\x05\xCD\x0C\xAF`s\x1B\x81RP` \x80Ta\x01\xF0\x90a\x0EZV[`@Q` \x01a\x05\xA2\x92\x91\x90a\x0F\xE3V[`@Q` \x81\x83\x03\x03\x81R\x90`@R`%\x90\x81a\x05\xBF\x91\x90a\x0E\xDEV[Pa\x06\x03a\x05\xD7a\x05\xD2`\x08`\x02a\x0F\xD0V[a\t\x85V[`@Q` \x01a\x05\xE7\x91\x90a\x0F\xF7V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x03\x1C\x90a\x0EZV[`&Ua\x06Da\x06\x18a\x05\xD2`\x08`\x02a\x0F\xD0V[`@Q` \x01a\x06(\x91\x90a\x10-V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x01\xF0\x90a\x0EZV[`'\x90a\x06Q\x90\x82a\x0E\xDEV[P_a\x06\x88`@Q\x80`@\x01`@R\x80`\x0C\x81R` \x01k\x05\xCC\xEC\xAD\xCC\xAEm.e\xCD\x0C\xAF`\xA3\x1B\x81RP` \x80Ta\x01\xF0\x90a\x0EZV[`\x1FT`@Qce\xDAA\xB9`\xE0\x1B\x81R\x91\x92Pa\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90ce\xDAA\xB9\x90a\x06\xC1\x90\x84\x90`$\x90`\x04\x01a\x10]V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x06\xDDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x01\x91\x90a\x10\xFAV[P`\x1FT`@Qce\xDAA\xB9`\xE0\x1B\x81Ra\x01\0\x90\x91\x04`\x01`\x01`\xA0\x1B\x03\x16\x90ce\xDAA\xB9\x90a\x079\x90\x84\x90`%\x90`\x04\x01a\x10]V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x07UW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07y\x91\x90a\x10\xFAV[PPPa\x12\x1EV[`@Qc\x1F\xB2C}`\xE3\x1B\x81R``\x90_Q` aa\xAA_9_Q\x90_R\x90c\xFD\x92\x1B\xE8\x90a\x07\xB6\x90\x86\x90\x86\x90`\x04\x01a\x11 V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07\xD0W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x07\xF7\x91\x90\x81\x01\x90a\r{V[\x90P[\x92\x91PPV[`@QcV\xEE\xF1[`\xE1\x1B\x81R_\x90_Q` aa\xAA_9_Q\x90_R\x90c\xAD\xDD\xE2\xB6\x90a\x084\x90\x86\x90\x86\x90`\x04\x01a\x11 V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08OW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xF7\x91\x90a\x11DV[`@Qc\x17w\xE5\x9D`\xE0\x1B\x81R_\x90_Q` aa\xAA_9_Q\x90_R\x90c\x17w\xE5\x9D\x90a\x084\x90\x86\x90\x86\x90`\x04\x01a\x11 V[``a\x08\xDC\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01hdigest_le`\xB8\x1B\x81RPa\n\x81` \x1B` \x1CV[\x94\x93PPPPV[``a\x08\xDC\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01b\r\x0C\xAF`\xEB\x1B\x81RPa\x0B1` \x1B` \x1CV[``_a\t!\x85\x85\x85a\x08\xE4V[\x90P_[a\t/\x85\x85a\x11[V[\x81\x10\x15a\t|W\x82\x82\x82\x81Q\x81\x10a\tIWa\tIa\x11nV[` \x02` \x01\x01Q`@Q` \x01a\tb\x92\x91\x90a\x0F\xE3V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\t%V[PP\x93\x92PPPV[``\x81_\x03a\t\xABWPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R`\x03`\xFC\x1B` \x82\x01R\x90V[\x81_[\x81\x15a\t\xD4W\x80a\t\xBE\x81a\x11\x82V[\x91Pa\t\xCD\x90P`\n\x83a\x11\xAEV[\x91Pa\t\xAEV[_\x81`\x01`\x01`@\x1B\x03\x81\x11\x15a\t\xEDWa\t\xEDa\x0C\xF2V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\n\x17W` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x08\xDCWa\n,`\x01\x83a\x11[V[\x91Pa\n9`\n\x86a\x11\xC1V[a\nD\x90`0a\x0F\xD0V[`\xF8\x1B\x81\x83\x81Q\x81\x10a\nYWa\nYa\x11nV[` \x01\x01\x90`\x01`\x01`\xF8\x1B\x03\x19\x16\x90\x81_\x1A\x90SPa\nz`\n\x86a\x11\xAEV[\x94Pa\n\x1BV[``a\n\x8D\x84\x84a\x11[V[`\x01`\x01`@\x1B\x03\x81\x11\x15a\n\xA4Wa\n\xA4a\x0C\xF2V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\n\xCDW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x0B(Wa\n\xFA\x86a\n\xE7\x83a\t\x85V[\x85`@Q` \x01a\x05\xE7\x93\x92\x91\x90a\x11\xD4V[\x82a\x0B\x05\x87\x84a\x11[V[\x81Q\x81\x10a\x0B\x15Wa\x0B\x15a\x11nV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\n\xD2V[P\x94\x93PPPPV[``a\x0B=\x84\x84a\x11[V[`\x01`\x01`@\x1B\x03\x81\x11\x15a\x0BTWa\x0BTa\x0C\xF2V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0B\x87W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x0BrW\x90P[P\x90P\x83[\x83\x81\x10\x15a\x0B(Wa\x0B\xB4\x86a\x0B\xA1\x83a\t\x85V[\x85`@Q` \x01a\x06(\x93\x92\x91\x90a\x11\xD4V[\x82a\x0B\xBF\x87\x84a\x11[V[\x81Q\x81\x10a\x0B\xCFWa\x0B\xCFa\x11nV[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x0B\x8CV[a);\x80a8o\x839\x01\x90V[\x82\x80T\x82\x82U\x90_R` _ \x90\x81\x01\x92\x82\x15a\x0C(W\x91` \x02\x82\x01[\x82\x81\x11\x15a\x0C(W\x82Q\x82U\x91` \x01\x91\x90`\x01\x01\x90a\x0C\rV[Pa\x0C4\x92\x91Pa\x0C\x88V[P\x90V[\x82\x80T\x82\x82U\x90_R` _ \x90\x81\x01\x92\x82\x15a\x0C|W\x91` \x02\x82\x01[\x82\x81\x11\x15a\x0C|W\x82Q\x82\x90a\x0Cl\x90\x82a\x0E\xDEV[P\x91` \x01\x91\x90`\x01\x01\x90a\x0CVV[Pa\x0C4\x92\x91Pa\x0C\x9CV[[\x80\x82\x11\x15a\x0C4W_\x81U`\x01\x01a\x0C\x89V[\x80\x82\x11\x15a\x0C4W_a\x0C\xAF\x82\x82a\x0C\xB8V[P`\x01\x01a\x0C\x9CV[P\x80Ta\x0C\xC4\x90a\x0EZV[_\x82U\x80`\x1F\x10a\x0C\xD3WPPV[`\x1F\x01` \x90\x04\x90_R` _ \x90\x81\x01\x90a\x0C\xEF\x91\x90a\x0C\x88V[PV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x80`\x01`\x01`@\x1B\x03\x84\x11\x15a\r\x1FWa\r\x1Fa\x0C\xF2V[P`@Q`\x1F\x19`\x1F\x85\x01\x81\x16`?\x01\x16\x81\x01\x81\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17\x15a\rMWa\rMa\x0C\xF2V[`@R\x83\x81R\x90P\x80\x82\x84\x01\x85\x10\x15a\rdW__\xFD[\x83\x83` \x83\x01^_` \x85\x83\x01\x01RP\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\r\x8BW__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\r\xA0W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\r\xB0W__\xFD[a\x08\xDC\x84\x82Q` \x84\x01a\r\x06V[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\r\xE1\x82\x85a\r\xBFV[\x7F/test/fullRelay/testData/\0\0\0\0\0\0\0\x81Ra\x0E\x11`\x19\x82\x01\x85a\r\xBFV[\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R_a\x07\xF7` \x83\x01\x84a\x0E\x1AV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x0EnW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x0E\x8CWcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\x0E\xD9W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x0E\xB7WP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x0E\xD6W_\x81U`\x01\x01a\x0E\xC3V[PP[PPPV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x0E\xF7Wa\x0E\xF7a\x0C\xF2V[a\x0F\x0B\x81a\x0F\x05\x84Ta\x0EZV[\x84a\x0E\x92V[` `\x1F\x82\x11`\x01\x81\x14a\x0F=W_\x83\x15a\x0F&WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x0E\xD6V[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x0FlW\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x0FLV[P\x84\x82\x10\x15a\x0F\x89W\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[``\x81R_a\x0F\xAA``\x83\x01\x86a\x0E\x1AV[` \x83\x01\x94\x90\x94RP`@\x01R\x91\x90PV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x80\x82\x01\x80\x82\x11\x15a\x07\xFAWa\x07\xFAa\x0F\xBCV[_a\x08\xDCa\x0F\xF1\x83\x86a\r\xBFV[\x84a\r\xBFV[f.chain[`\xC8\x1B\x81R_a\x10\x12`\x07\x83\x01\x84a\r\xBFV[j].digest_le`\xA8\x1B\x81R`\x0B\x01\x93\x92PPPV[f.chain[`\xC8\x1B\x81R_a\x10H`\x07\x83\x01\x84a\r\xBFV[d\x0B\xA5\xCD\x0C\xAF`\xDB\x1B\x81R`\x05\x01\x93\x92PPPV[`@\x81R_a\x10o`@\x83\x01\x85a\x0E\x1AV[\x82\x81\x03` \x84\x01R_\x84Ta\x10\x83\x81a\x0EZV[\x80\x84R`\x01\x82\x16\x80\x15a\x10\x9DW`\x01\x81\x14a\x10\xB9Wa\x10\xEDV[`\xFF\x19\x83\x16` \x86\x01R` \x82\x15\x15`\x05\x1B\x86\x01\x01\x93Pa\x10\xEDV[\x87_R` _ _[\x83\x81\x10\x15a\x10\xE4W\x81T` \x82\x89\x01\x01R`\x01\x82\x01\x91P` \x81\x01\x90Pa\x10\xC2V[\x86\x01` \x01\x94PP[P\x91\x97\x96PPPPPPPV[_` \x82\x84\x03\x12\x15a\x11\nW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x11\x19W__\xFD[\x93\x92PPPV[`@\x81R_a\x112`@\x83\x01\x85a\x0E\x1AV[\x82\x81\x03` \x84\x01Ra\x0E\x11\x81\x85a\x0E\x1AV[_` \x82\x84\x03\x12\x15a\x11TW__\xFD[PQ\x91\x90PV[\x81\x81\x03\x81\x81\x11\x15a\x07\xFAWa\x07\xFAa\x0F\xBCV[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[_`\x01\x82\x01a\x11\x93Wa\x11\x93a\x0F\xBCV[P`\x01\x01\x90V[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x11\xBCWa\x11\xBCa\x11\x9AV[P\x04\x90V[_\x82a\x11\xCFWa\x11\xCFa\x11\x9AV[P\x06\x90V[`\x17`\xF9\x1B\x81R_a\x11\xE9`\x01\x83\x01\x86a\r\xBFV[`[`\xF8\x1B\x81Ra\x11\xFD`\x01\x82\x01\x86a\r\xBFV[\x90Pa.\x97`\xF1\x1B\x81Ra\x12\x14`\x02\x82\x01\x85a\r\xBFV[\x96\x95PPPPPPV[a&D\x80a\x12+_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x8FW_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\xDDW\x80c\xD2\xAD\xDB\xB8\x11a\0\x88W\x80c\xF3\xAC%\x0C\x11a\0cW\x80c\xF3\xAC%\x0C\x14a\x02\xDFW\x80c\xFAv&\xD4\x14a\x02\xE7W\x80c\xFA\xD0k\x8F\x14a\x02\xF4W__\xFD[\x80c\xD2\xAD\xDB\xB8\x14a\x02\xC7W\x80c\xDB\x84\xFC\x88\x14a\x02\xCFW\x80c\xE2\x0C\x9Fq\x14a\x02\xD7W__\xFD[\x80c\xB0FO\xDC\x11a\0\xB8W\x80c\xB0FO\xDC\x14a\x02\x9FW\x80c\xB5P\x8A\xA9\x14a\x02\xA7W\x80c\xBAAO\xA6\x14a\x02\xAFW__\xFD[\x80c\x91j\x17\xC6\x14a\x02zW\x80c\x96\xA7\x8Dw\x14a\x02\x8FW\x80c\x97\xEC6\xE9\x14a\x02\x97W__\xFD[\x80c?r\x86\xF4\x11a\x01=W\x80cf\xD9\xA9\xA0\x11a\x01\x18W\x80cf\xD9\xA9\xA0\x14a\x02HW\x80c\x82}}\xB1\x14a\x02]W\x80c\x85\"l\x81\x14a\x02eW__\xFD[\x80c?r\x86\xF4\x14a\x02\x18W\x80cD\xBA\xDB\xB6\x14a\x02 W\x80ca\xAC\x80\x13\x14a\x02@W__\xFD[\x80c\x1E\xD7\x83\x1C\x11a\x01mW\x80c\x1E\xD7\x83\x1C\x14a\x01\xE6W\x80c*\xDE8\x80\x14a\x01\xFBW\x80c>^<#\x14a\x02\x10W__\xFD[\x80c\x08\x13\x85*\x14a\x01\x93W\x80c\x18\xAA\xE3l\x14a\x01\xBCW\x80c\x1C\r\xA8\x1F\x14a\x01\xC6W[__\xFD[a\x01\xA6a\x01\xA16`\x04a\x1D\xF9V[a\x03\x07V[`@Qa\x01\xB3\x91\x90a\x1E\xAEV[`@Q\x80\x91\x03\x90\xF3[a\x01\xC4a\x03RV[\0[a\x01\xD9a\x01\xD46`\x04a\x1D\xF9V[a\x04\xB0V[`@Qa\x01\xB3\x91\x90a\x1F\x11V[a\x01\xEEa\x05\"V[`@Qa\x01\xB3\x91\x90a\x1F#V[a\x02\x03a\x05\x82V[`@Qa\x01\xB3\x91\x90a\x1F\xC8V[a\x01\xEEa\x06\xBEV[a\x01\xEEa\x07\x1CV[a\x023a\x02.6`\x04a\x1D\xF9V[a\x07zV[`@Qa\x01\xB3\x91\x90a ?V[a\x01\xC4a\x07\xBDV[a\x02Pa\x08\xB3V[`@Qa\x01\xB3\x91\x90a \xD2V[a\x01\xC4a\n,V[a\x02ma\x0BWV[`@Qa\x01\xB3\x91\x90a!PV[a\x02\x82a\x0C\"V[`@Qa\x01\xB3\x91\x90a!bV[a\x01\xC4a\r\x18V[a\x01\xC4a\x0E\x0BV[a\x02\x82a\x0F\x10V[a\x02ma\x10\x06V[a\x02\xB7a\x10\xD1V[`@Q\x90\x15\x15\x81R` \x01a\x01\xB3V[a\x01\xC4a\x11\xA1V[a\x01\xC4a\x12\x0BV[a\x01\xEEa\x15\xC7V[a\x01\xC4a\x16%V[`\x1FTa\x02\xB7\x90`\xFF\x16\x81V[a\x023a\x03\x026`\x04a\x1D\xF9V[a\x17\x0EV[``a\x03J\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x17QV[\x94\x93PPPPV[sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\xF2\x8D\xCE\xB3`@Q\x80``\x01`@R\x80`0\x81R` \x01a%\xDF`0\x919`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x03\xAA\x91\x90a\x1F\x11V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x03\xC1W__\xFD[PZ\xF1\x15\x80\x15a\x03\xD3W=__>=_\xFD[PPPP`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16c\xB2[\x9B\0`\"`\x03\x81T\x81\x10a\x04\x0FWa\x04\x0Fa!\xD9V[\x90_R` _ \x01T`#`\x04\x81T\x81\x10a\x04,Wa\x04,a!\xD9V[\x90_R` _ \x01`#`\x02\x81T\x81\x10a\x04HWa\x04Ha!\xD9V[\x90_R` _ \x01`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x04n\x93\x92\x91\x90a#,V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04\x89W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04\xAD\x91\x90a#`V[PV[``_a\x04\xBE\x85\x85\x85a\x03\x07V[\x90P_[a\x04\xCC\x85\x85a#\xA4V[\x81\x10\x15a\x05\x19W\x82\x82\x82\x81Q\x81\x10a\x04\xE6Wa\x04\xE6a!\xD9V[` \x02` \x01\x01Q`@Q` \x01a\x04\xFF\x92\x91\x90a#\xCEV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x04\xC2V[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x05xW` \x02\x82\x01\x91\x90_R` _ \x90[\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x05ZW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06\xB5W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x06\x9EW\x83\x82\x90_R` _ \x01\x80Ta\x06\x13\x90a\"\x06V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06?\x90a\"\x06V[\x80\x15a\x06\x8AW\x80`\x1F\x10a\x06aWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x06\x8AV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x06mW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x05\xF6V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05\xA5V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x05xW` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x05ZWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x05xW` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x05ZWPPPPP\x90P\x90V[``a\x03J\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x18(V[sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\xF2\x8D\xCE\xB3`@Q\x80``\x01`@R\x80`0\x81R` \x01a%\xDF`0\x919`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x08\x15\x91\x90a\x1F\x11V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08,W__\xFD[PZ\xF1\x15\x80\x15a\x08>W=__>=_\xFD[PPPP`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16c\xB2[\x9B\0`\"`\x03\x81T\x81\x10a\x08zWa\x08za!\xD9V[\x90_R` _ \x01T`#`\x02\x81T\x81\x10a\x08\x97Wa\x08\x97a!\xD9V[\x90_R` _ \x01`#`\x04\x81T\x81\x10a\x04HWa\x04Ha!\xD9V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06\xB5W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\t\x06\x90a\"\x06V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\t2\x90a\"\x06V[\x80\x15a\t}W\x80`\x1F\x10a\tTWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\t}V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t`W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\n\x14W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\t\xC1W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x08\xD6V[`@\x80Q\x80\x82\x01\x82R`\r\x81R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\n\xAD\x91\x90`\x04\x01a\x1F\x11V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\n\xC4W__\xFD[PZ\xF1\x15\x80\x15a\n\xD6W=__>=_\xFD[PPPP`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16c\xB2[\x9B\0`\"`\x03\x81T\x81\x10a\x0B\x12Wa\x0B\x12a!\xD9V[\x90_R` _ \x01T`#`\x04\x81T\x81\x10a\x0B/Wa\x0B/a!\xD9V[\x90_R` _ \x01`'`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x04n\x93\x92\x91\x90a#,V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06\xB5W\x83\x82\x90_R` _ \x01\x80Ta\x0B\x97\x90a\"\x06V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\xC3\x90a\"\x06V[\x80\x15a\x0C\x0EW\x80`\x1F\x10a\x0B\xE5Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C\x0EV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xF1W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0BzV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06\xB5W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\0W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C\xADW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0CEV[`\x1FT`\"\x80Ta\x0E\t\x92a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x91c\xB2[\x9B\0\x91`\x03\x90\x81\x10a\rIWa\rIa!\xD9V[\x90_R` _ \x01T`#`\x04\x81T\x81\x10a\rfWa\rfa!\xD9V[\x90_R` _ \x01`#`\x05\x81T\x81\x10a\r\x82Wa\r\x82a!\xD9V[\x90_R` _ \x01`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\r\xA8\x93\x92\x91\x90a#,V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\r\xC3W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\xE7\x91\x90a#`V[`\"`\x05\x81T\x81\x10a\r\xFBWa\r\xFBa!\xD9V[\x90_R` _ \x01Ta\x18\xECV[V[`@\x80Q\x80\x82\x01\x82R`\r\x81R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x0E\x8C\x91\x90`\x04\x01a\x1F\x11V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0E\xA3W__\xFD[PZ\xF1\x15\x80\x15a\x0E\xB5W=__>=_\xFD[PPPP`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16c\xB2[\x9B\0`\"`\x03\x81T\x81\x10a\x0E\xF1Wa\x0E\xF1a!\xD9V[\x90_R` _ \x01T`'`#`\x04\x81T\x81\x10a\x04HWa\x04Ha!\xD9V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06\xB5W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0F\xEEW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0F\x9BW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0F3V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06\xB5W\x83\x82\x90_R` _ \x01\x80Ta\x10F\x90a\"\x06V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x10r\x90a\"\x06V[\x80\x15a\x10\xBDW\x80`\x1F\x10a\x10\x94Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x10\xBDV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x10\xA0W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x10)V[`\x08T_\x90`\xFF\x16\x15a\x10\xE8WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11vW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\x9A\x91\x90a#`V[\x14\x15\x90P\x90V[`\x1FT`\"\x80Ta\x0E\t\x92a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x91c\xB2[\x9B\0\x91`\x03\x90\x81\x10a\x11\xD2Wa\x11\xD2a!\xD9V[\x90_R` _ \x01T`#`\x05\x81T\x81\x10a\x11\xEFWa\x11\xEFa!\xD9V[\x90_R` _ \x01`#`\x04\x81T\x81\x10a\r\x82Wa\r\x82a!\xD9V[_a\x12\xDC`@Q\x80`@\x01`@R\x80`\x18\x81R` \x01\x7F.orphan_562630.digest_le\0\0\0\0\0\0\0\0\x81RP` \x80Ta\x12R\x90a\"\x06V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x12~\x90a\"\x06V[\x80\x15a\x12\xC9W\x80`\x1F\x10a\x12\xA0Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x12\xC9V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x12\xACW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x19o\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90P_a\x13\xAF`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01\x7F.orphan_562630.hex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x80Ta\x13%\x90a\"\x06V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x13Q\x90a\"\x06V[\x80\x15a\x13\x9CW\x80`\x1F\x10a\x13sWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x13\x9CV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x13\x7FW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x1A\x0B\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90P_a\x13\xFA`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01\x7Fchain\0\0\0\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`\x08\x80`\x01a\x02.\x91\x90a#\xE2V[_\x81Q\x81\x10a\x14\x0BWa\x14\x0Ba!\xD9V[` \x02` \x01\x01Q\x90P_a\x14^`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01\x7Fchain\0\0\0\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`\x08\x80`\x01a\x01\xA1\x91\x90a#\xE2V[_\x81Q\x81\x10a\x14oWa\x14oa!\xD9V[` \x02` \x01\x01Q\x90Pa\x15\"`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16c\xB2[\x9B\0`\"`\x03\x81T\x81\x10a\x14\xB4Wa\x14\xB4a!\xD9V[\x90_R` _ \x01T\x84\x87`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x14\xDD\x93\x92\x91\x90a#\xF5V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x14\xF8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x15\x1C\x91\x90a#`V[\x83a\x18\xECV[`\x1FT`\"\x80Ta\x15\xC1\x92a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x91c\xB2[\x9B\0\x91`\x03\x90\x81\x10a\x15SWa\x15Sa!\xD9V[\x90_R` _ \x01T\x86\x85`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x15|\x93\x92\x91\x90a#\xF5V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x15\x97W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x15\xBB\x91\x90a#`V[\x85a\x18\xECV[PPPPV[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x05xW` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x05ZWPPPPP\x90P\x90V[`@\x80Q\x80\x82\x01\x82R`\r\x81R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x16\xA6\x91\x90`\x04\x01a\x1F\x11V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x16\xBDW__\xFD[PZ\xF1\x15\x80\x15a\x16\xCFW=__>=_\xFD[PPPP`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16c\xB2[\x9B\0`&T`#`\x03\x81T\x81\x10a\x08\x97Wa\x08\x97a!\xD9V[``a\x03J\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1A\xA1V[``a\x17]\x84\x84a#\xA4V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17uWa\x17ua\x1DtV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x17\xA8W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x17\x93W\x90P[P\x90P\x83[\x83\x81\x10\x15a\x18\x1FWa\x17\xF1\x86a\x17\xC2\x83a\x1B\xEFV[\x85`@Q` \x01a\x17\xD5\x93\x92\x91\x90a$\x1FV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x13%\x90a\"\x06V[\x82a\x17\xFC\x87\x84a#\xA4V[\x81Q\x81\x10a\x18\x0CWa\x18\x0Ca!\xD9V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x17\xADV[P\x94\x93PPPPV[``a\x184\x84\x84a#\xA4V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18LWa\x18La\x1DtV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x18uW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x18\x1FWa\x18\xBE\x86a\x18\x8F\x83a\x1B\xEFV[\x85`@Q` \x01a\x18\xA2\x93\x92\x91\x90a$\x1FV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x12R\x90a\"\x06V[\x82a\x18\xC9\x87\x84a#\xA4V[\x81Q\x81\x10a\x18\xD9Wa\x18\xD9a!\xD9V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x18zV[`@Q\x7F|\x84\xC6\x9B\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c|\x84\xC6\x9B\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x19UW__\xFD[PZ\xFA\x15\x80\x15a\x19gW=__>=_\xFD[PPPPPPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x19\xC3\x90\x86\x90\x86\x90`\x04\x01a$\xB2V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x19\xDEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1A\x02\x91\x90a#`V[\x90P[\x92\x91PPV[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a\x1A`\x90\x86\x90\x86\x90`\x04\x01a$\xB2V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1AzW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x1A\x02\x91\x90\x81\x01\x90a$\xDFV[``a\x1A\xAD\x84\x84a#\xA4V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1A\xC5Wa\x1A\xC5a\x1DtV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x1A\xEEW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x18\x1FWa\x1B\xC1\x86a\x1B\x08\x83a\x1B\xEFV[\x85`@Q` \x01a\x1B\x1B\x93\x92\x91\x90a$\x1FV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x1B7\x90a\"\x06V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x1Bc\x90a\"\x06V[\x80\x15a\x1B\xAEW\x80`\x1F\x10a\x1B\x85Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x1B\xAEV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x1B\x91W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x1D \x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x1B\xCC\x87\x84a#\xA4V[\x81Q\x81\x10a\x1B\xDCWa\x1B\xDCa!\xD9V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x1A\xF3V[``\x81_\x03a\x1C1WPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x1CZW\x80a\x1CD\x81a%TV[\x91Pa\x1CS\x90P`\n\x83a%\xB8V[\x91Pa\x1C4V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1CtWa\x1Cta\x1DtV[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x1C\x9EW` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x03JWa\x1C\xB3`\x01\x83a#\xA4V[\x91Pa\x1C\xC0`\n\x86a%\xCBV[a\x1C\xCB\x90`0a#\xE2V[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x1C\xE0Wa\x1C\xE0a!\xD9V[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x1D\x19`\n\x86a%\xB8V[\x94Pa\x1C\xA2V[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x19\xC3\x90\x86\x90\x86\x90`\x04\x01a$\xB2V[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x1D\xCAWa\x1D\xCAa\x1DtV[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x1D\xEBWa\x1D\xEBa\x1DtV[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x1E\x0BW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E!W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x1E1W__\xFD[\x805a\x1EDa\x1E?\x82a\x1D\xD2V[a\x1D\xA1V[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x1EXW__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1F\x05W`?\x19\x87\x86\x03\x01\x84Ra\x1E\xF0\x85\x83Qa\x1E\x80V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1E\xD4V[P\x92\x96\x95PPPPPPV[` \x81R_a\x1A\x02` \x83\x01\x84a\x1E\x80V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1FcW\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1F=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x04NV[`@Q` \x01a\x01\xC8\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x01\xE2\x91a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\xFDW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02 \x91\x90a\x04NV[\x92\x91PPV[_a\x02 a\x023\x83a\x028V[a\x02CV[_a\x02 \x82\x82a\x02SV[_a\x02 a\xFF\xFF`\xD0\x1B\x83a\x02\xF7V[_\x80a\x02ja\x02c\x84`Ha\x04eV[\x85\x90a\x03\tV[`\xE8\x1C\x90P_\x84a\x02|\x85`Ka\x04eV[\x81Q\x81\x10a\x02\x8CWa\x02\x8Ca\x04xV[\x01` \x01Q`\xF8\x1C\x90P_a\x02\xBE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x02\xD1`\x03\x84a\x04\x8CV[`\xFF\x16\x90Pa\x02\xE2\x81a\x01\0a\x05\x88V[a\x02\xEC\x90\x83a\x05\x93V[\x97\x96PPPPPPPV[_a\x03\x02\x82\x84a\x05\xAAV[\x93\x92PPPV[_a\x03\x02\x83\x83\x01` \x01Q\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x03=W__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03RW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03bW__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03{Wa\x03{a\x03\x17V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x03\xA9Wa\x03\xA9a\x03\x17V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x03\xC0W__\xFD[\x81` \x84\x01` \x83\x01^_` \x92\x82\x01\x83\x01R\x90\x86\x01Q`@\x90\x96\x01Q\x90\x97\x95\x96P\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x04\x0CWa\x04\x0Ca\x03\xEAV[P\x06\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x04^W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02 Wa\x02 a\x04\x11V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[`\x01\x81[`\x01\x84\x11\x15a\x04\xE0W\x80\x85\x04\x81\x11\x15a\x04\xC4Wa\x04\xC4a\x04\x11V[`\x01\x84\x16\x15a\x04\xD2W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x04\xA9V[\x93P\x93\x91PPV[_\x82a\x04\xF6WP`\x01a\x02 V[\x81a\x05\x02WP_a\x02 V[\x81`\x01\x81\x14a\x05\x18W`\x02\x81\x14a\x05\"Wa\x05>V[`\x01\x91PPa\x02 V[`\xFF\x84\x11\x15a\x053Wa\x053a\x04\x11V[PP`\x01\x82\x1Ba\x02 V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x05aWP\x81\x81\na\x02 V[a\x05m_\x19\x84\x84a\x04\xA5V[\x80_\x19\x04\x82\x11\x15a\x05\x80Wa\x05\x80a\x04\x11V[\x02\x93\x92PPPV[_a\x03\x02\x83\x83a\x04\xE8V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x02 Wa\x02 a\x04\x11V[_\x82a\x05\xB8Wa\x05\xB8a\x03\xEAV[P\x04\x90V[a#q\x80a\x05\xCA_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\xADW\x80c\xB9\x85b\x1A\x11a\0}W\x80c\xE3\xD8\xD8\xD8\x11a\0cW\x80c\xE3\xD8\xD8\xD8\x14a\x02\"W\x80c\xE4q\xE7,\x14a\x02)W\x80c\xF5\x8D\xB0o\x14a\x02=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x13\x91\x90a!WV[`@Q` \x01a\x0C%\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\x90\x82\x90Ra\x0C]\x91a!AV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0CxW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x07\x91\x90a!WV[_\x83\x85\x14\x80\x15a\x0C\xAAWP\x82\x85\x14[\x15a\x0C\xB7WP`\x01a\x04\xF1V[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x0C\xFFW\x89\x83\x14a\x0C\xDEW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x0C\xF7W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x0C\xBDV[P\x82\x84\x03a\r\x13W_\x94PPPPPa\x04\xF1V[\x80\x82\x14a\r&W_\x94PPPPPa\x04\xF1V[P`\x01\x98\x97PPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\rYW_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\r9V[P\x80a\x05\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x80\x82\x81[a\r\xB8`\x04`\x01a!\x9BV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0E\x0CW_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\r\xF1W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0E\x04V[a\r\xFB\x81\x84a!\xB7V[\x95\x94PPPPPV[`\x01\x01a\r\xACV[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_`P\x82Qa\x0B~\x91\x90a!.V[__a\x0Eo\x85a\x0B\xC3V[\x90P_a\x0E{\x82a\r\xA7V[\x90P_a\x0E\x87\x86a\x19\xE6V[\x90P\x84\x80a\x0E\x9CWP\x80a\x0E\x9A\x88a\x19\xE6V[\x14[a\x0F\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x03.V[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x12\x0EWa\x0F(`P\x82a!\xCAV[a\x0F3\x90`\x01a!\xB7V[a\x0F=\x90\x87a!\xB7V[\x93Pa\x0FK\x8A\x82`Pa\x19\xF1V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x11!W\x84a\x10\xA1\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x10\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x11\n`\x04\x85a!.V[_\x03a\x11!W_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x11,\x8B\x83a\x1A\x16V[\x14a\x11yW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[\x86a\x11\x84\x8B\x83a\x1A\xAFV[\x14a\x11\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x03.V[\x82\x96P`P\x81a\x12\x07\x91\x90a!\xB7V[\x90Pa\x0F\x15V[P\x81a\x12\x19\x8Ba\x0B\xC3V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x12\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x12\xD4\x84a\x0B\xC3V[\x90P_a\x12\xE0\x86a\x0B\xC3V[\x90P`\x01T\x81\x14a\x133W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x03.V[_\x82\x81R`\x03` R`@\x90 Ta\x13\x8DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x13\x9B\x87`\x01T\x84\x87a\x0C\x9BV[a\x14\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x03.V[\x81a\x14\x19\x88\x88\x88a\x17\x80V[\x14a\x14\x8CW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[`\x01\x82\x90U`\x02\x87\x90U_a\x14\xA0\x86a\x1A\xC7V[\x90P`\x05T\x81\x14a\x14\xB1W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x15\x01a\x14\xFC\x86a\x0B\xC3V[a\r\xA7V[\x90P_a\x15\x10a\x14\xFC\x86a\x0B\xC3V[\x90Pa\x15\x1Ea\x07\xE0\x82a!.V[a\x07\xDF\x14a\x15\x94W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x03.V[a\x15\xA0\x82a\x07\xDFa!\xB7V[\x81\x14a\x16\x14W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x03.V[a\x16\x1D\x85a\x1A\xC7V[a\x16&\x87a\x1A\xC7V[\x14a\x16\x99W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x03.V[_a\x16\xA3\x85a\x19\xE6V[\x90P_a\x16\xD5a\x16\xB2\x89a\x19\xE6V[a\x16\xBB\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x16\xCA\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x1B\x0CV[\x90P\x81\x81\x83\x16\x14a\x17(W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_a\x172\x89a\x1A\xC7V[\x90P\x80`\x06T\x14\x15\x80\x15a\x17\\WPa\x07\xE0a\x17O`\x01Ta\r\xA7V[a\x17Y\x91\x90a!\xDDV[\x84\x11[\x15a\x17gW`\x06\x81\x90U[a\x17s\x88\x88`\x01a\x0EdV[\x99\x98PPPPPPPPPV[__a\x17\x8B\x85a\r\xA7V[\x90P_a\x17\x9Aa\x14\xFC\x86a\x0B\xC3V[\x90P_a\x17\xA9a\x14\xFC\x86a\x0B\xC3V[\x90P\x82\x82\x10\x15\x80\x15a\x17\xBBWP\x82\x81\x10\x15[a\x18-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x18:a\x07\xE0\x85a!.V[a\x18F\x85a\x07\xE0a!\xB7V[a\x18P\x91\x90a!\xDDV[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x18bWP\x80[\x15a\x18}Wa\x18p\x89a\x0B\xC3V[\x96PPPPPPPa\n\xA3V[\x81\x80\x15a\x18\x88WP\x80\x15[\x15a\x18\x96Wa\x18p\x88a\x0B\xC3V[\x81\x80\x15a\x18\xA0WP\x80[\x15a\x18\xC4W\x83\x85\x10\x15a\x18\xBBWa\x18\xB6\x88a\x0B\xC3V[a\x18pV[a\x18p\x89a\x0B\xC3V[a\x18\xCD\x88a\x1A\xC7V[a\x18\xD9a\x07\xE0\x86a!.V[a\x18\xE3\x91\x90a!\xF0V[a\x18\xEC\x8Aa\x1A\xC7V[a\x18\xF8a\x07\xE0\x88a!.V[a\x19\x02\x91\x90a!\xF0V[\x10\x15a\x18\xBBWa\x18p\x88a\x0B\xC3V[`\x07T_\x90`\xFF\x16\x15a\x19/WP`\x07Ta\x01\0\x90\x04`\xFF\x16a\n\xA3V[a\x19:\x84\x84\x84a\x1B\x94V[\x90Pa\n\xA3V[_` \x84Qa\x19P\x91\x90a!.V[\x15a\x19\\WP_a\x04\xF1V[\x83Q_\x03a\x19kWP_a\x04\xF1V[\x81\x85_[\x86Q\x81\x10\x15a\x19\xD9Wa\x19\x83`\x02\x84a!.V[`\x01\x03a\x19\xA7Wa\x19\xA0a\x19\x9A\x88\x83\x01` \x01Q\x90V[\x83a\x1B\xD5V[\x91Pa\x19\xC0V[a\x19\xBD\x82a\x19\xB8\x89\x84\x01` \x01Q\x90V[a\x1B\xD5V[\x91P[`\x01\x92\x90\x92\x1C\x91a\x19\xD2` \x82a!\xB7V[\x90Pa\x19oV[P\x90\x93\x14\x95\x94PPPPPV[_a\x05\x07\x82_a\x1A\x16V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x1A-a\x1A&\x84`Ha!\xB7V[\x85\x90a\x1B\xE0V[`\xE8\x1C\x90P_\x84a\x1A?\x85`Ka!\xB7V[\x81Q\x81\x10a\x1AOWa\x1AOa\"\x07V[\x01` \x01Q`\xF8\x1C\x90P_a\x1A\x81\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1A\x94`\x03\x84a\"4V[`\xFF\x16\x90Pa\x1A\xA5\x81a\x01\0a#0V[a\x08-\x90\x83a!\xF0V[_a\x05\x04a\x1A\xBE\x83`\x04a!\xB7V[\x84\x01` \x01Q\x90V[_a\x05\x07a\x1A\xD4\x83a\x19\xE6V[a\x1B\xEEV[_a\x05\x07a\x1A\xE6\x83a\x1C\x15V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1B\x18\x83\x85a\x1C!V[\x90Pa\x1B(b\x12u\0`\x04a\x1C|V[\x81\x10\x15a\x1B@Wa\x1B=b\x12u\0`\x04a\x1C|V[\x90P[a\x1BNb\x12u\0`\x04a\x1C\x87V[\x81\x11\x15a\x1BfWa\x1Bcb\x12u\0`\x04a\x1C\x87V[\x90P[_a\x1B~\x82a\x1Bx\x88b\x01\0\0a\x1C|V[\x90a\x1C\x87V[\x90Pa\n\x8Ab\x01\0\0a\x1Bx\x83b\x12u\0a\x1C|V[_\x82\x81[\x83\x81\x10\x15a\x1B\xCAW\x85\x82\x03a\x1B\xB2W`\x01\x92PPPa\n\xA3V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x1B\x98V[P_\x95\x94PPPPPV[_a\x05\x04\x83\x83a\x1C\xFAV[_a\x05\x04\x83\x83\x01` \x01Q\x90V[_a\x05\x07{\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\x83a\x1C|V[_a\x05\x07\x82`Da\x1B\xE0V[_\x82\x82\x11\x15a\x1CrW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x05\x04\x82\x84a!\xDDV[_a\x05\x04\x82\x84a!\xCAV[_\x82_\x03a\x1C\x96WP_a\x05\x07V[a\x1C\xA0\x82\x84a!\xF0V[\x90P\x81a\x1C\xAD\x84\x83a!\xCAV[\x14a\x05\x07W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x03.V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1D1W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DHW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1D_W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1DvW__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1D\x91W__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xA7W__\xFD[a\x1D\xB3\x8A\x82\x8B\x01a\x1D!V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xD2W__\xFD[a\x1D\xDE\x8A\x82\x8B\x01a\x1D!V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1D\xFE`\x80\x89\x01a\x1DfV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[____`\x80\x85\x87\x03\x12\x15a\x1E\x1FW__\xFD[PP\x825\x94` \x84\x015\x94P`@\x84\x015\x93``\x015\x92P\x90PV[__`@\x83\x85\x03\x12\x15a\x1ELW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1EkW__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1E\x85W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x9BW__\xFD[a\x1E\xA7\x87\x82\x88\x01a\x1D!V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\xC6W__\xFD[a\x1E\xD2\x87\x82\x88\x01a\x1D!V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1E\xF3W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x10W__\xFD[a\x1F\x1C\x89\x82\x8A\x01a\x1D!V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F;W__\xFD[a\x1FG\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1FtW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x8AW__\xFD[a\x1F\x96\x89\x82\x8A\x01a\x1D!V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xB5W__\xFD[a\x1F\xC1\x89\x82\x8A\x01a\x1D!V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xE0W__\xFD[a\x1F\xEC\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_____``\x86\x88\x03\x12\x15a \x12W__\xFD[\x855\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a /W__\xFD[a ;\x88\x82\x89\x01a\x1D!V[\x90\x95P\x93PP`@\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a ZW__\xFD[a f\x88\x82\x89\x01a\x1D!V[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[___``\x84\x86\x03\x12\x15a \x89W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a \xB1W__\xFD[\x825\x91Pa \xC1` \x84\x01a\x1DfV[\x90P\x92P\x92\x90PV[\x805\x80\x15\x15\x81\x14a\x1DvW__\xFD[__`@\x83\x85\x03\x12\x15a \xEAW__\xFD[a \xF3\x83a \xCAV[\x91Pa \xC1` \x84\x01a \xCAV[\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!^<#\x11a\0\xE8W\x80c>^<#\x14a\x01]W\x80c?r\x86\xF4\x14a\x01eW\x80cf\xD9\xA9\xA0\x14a\x01mW\x80ck9d\x13\x14a\x01\x82W__\xFD[\x80b?+\x1D\x14a\x01\x18W\x80c\n\x92T\xE4\x14a\x01\"W\x80c\x1E\xD7\x83\x1C\x14a\x01*W\x80c*\xDE8\x80\x14a\x01HW[__\xFD[a\x01 a\x024V[\0[a\x01 a\t\xF5V[a\x012a\n2V[`@Qa\x01?\x91\x90a\x1C\xE2V[`@Q\x80\x91\x03\x90\xF3[a\x01Pa\n\x92V[`@Qa\x01?\x91\x90a\x1D[V[a\x012a\x0B\xCEV[a\x012a\x0C,V[a\x01ua\x0C\x8AV[`@Qa\x01?\x91\x90a\x1E\x9EV[a\x01 a\x0E\x03V[a\x01\x92a\x14\xE5V[`@Qa\x01?\x91\x90a\x1F\x1CV[a\x01\xA7a\x15\xB0V[`@Qa\x01?\x91\x90a\x1FsV[a\x01\xA7a\x16\xA6V[a\x01\x92a\x17\x9CV[a\x01\xCCa\x18gV[`@Q\x90\x15\x15\x81R` \x01a\x01?V[a\x012a\x197V[a\x01 a\x01\xF26`\x04a \x01V[a\x19\x95V[`\x1FTa\x01\xCC\x90`\xFF\x16\x81V[`\x1FTa\x02\x1C\x90a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01?V[_s*\xC9\x8D\xB4\x1C\xBD1r\xCB{\x8F\xD8\xA8\xAB;\x91\xCF\xE4]\xCF\x90P_\x81`@Qa\x02Z\x90a\x1C\xA1V[`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x02\x83W=__>=_\xFD[P\x90P_sxH\xF0w^\xEB\xAB\xBFU\xCBtI\x0C\xE6\xD3g>hw:\x90P_\x81`@Qa\x02\xAC\x90a\x1C\xAEV[`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x02\xD5W=__>=_\xFD[P\x90P_\x83\x82`@Qa\x02\xE7\x90a\x1C\xBBV[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03\x17W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x03\x91W__\xFD[PZ\xF1\x15\x80\x15a\x03\xA3W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04\x19W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04=\x91\x90a FV[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xC4W__\xFD[PZ\xF1\x15\x80\x15a\x04\xD6W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05&W__\xFD[PZ\xF1\x15\x80\x15a\x058W=__>=_\xFD[PP`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01R_\x92P`\x01`\x01`\xA0\x1B\x03\x86\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x81W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xA5\x91\x90a lV[\x90Pa\x05\xE7\x81_`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01\x7FUser has seTokens\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1B\xD1V[`\x1FT`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01Ra\x06\x96\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90cp\xA0\x821\x90`$\x01[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x066W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06Z\x91\x90a lV[_`@Q\x80`@\x01`@R\x80`\x17\x81R` \x01\x7FUser has no WBTC tokens\0\0\0\0\0\0\0\0\0\x81RPa\x1CMV[_\x86`\x01`\x01`\xA0\x1B\x03\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD3W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF7\x91\x90a \x83V[`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01R\x90\x91Pa\x07\xA1\x90`\x01`\x01`\xA0\x1B\x03\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07AW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07e\x91\x90a lV[_`@Q\x80`@\x01`@R\x80`\x19\x81R` \x01\x7FUser has no uniBTC tokens\0\0\0\0\0\0\0\x81RPa\x1CMV[`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\x04W__\xFD[PZ\xF1\x15\x80\x15a\x08\x16W=__>=_\xFD[PP`@Q\x7F\xDB\0ju\0\0\0\0\0\0\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`\x01`\xA0\x1B\x03\x88\x16\x92Pc\xDB\0ju\x91P`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x08wW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\x9B\x91\x90a lV[P`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x86\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\xDFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\x03\x91\x90a lV[\x91Pa\tE\x82_`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01\x7FUser has redeemed\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1CMV[`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01Ra\t\xEC\x90`\x01`\x01`\xA0\x1B\x03\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\t\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\xB0\x91\x90a lV[_`@Q\x80`@\x01`@R\x80`\x1F\x81R` \x01\x7FUser increase in uniBTC Balance\0\x81RPa\x1B\xD1V[PPPPPPPV[a\n0bi\xFC\x8AsZ\x8E\x97t\xD6\x7F\xE8F\xC6\xF41\x1C\x07>*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x19\x95V[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\n\x88W` \x02\x82\x01\x91\x90_R` _ \x90[\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\njW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x0B\xAEW\x83\x82\x90_R` _ \x01\x80Ta\x0B#\x90a \x9EV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0BO\x90a \x9EV[\x80\x15a\x0B\x9AW\x80`\x1F\x10a\x0BqWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\x9AV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B}W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0B\x06V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\n\xB5V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\n\x88W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\njWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\n\x88W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\njWPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x0C\xDD\x90a \x9EV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\t\x90a \x9EV[\x80\x15a\rTW\x80`\x1F\x10a\r+Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rTV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r7W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\r\xEBW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\x98W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xADV[_sT\x1F\xD7IA\x9C\xA8\x06\xA8\xBC}\xA8\xAC#\xD3F\xF2\xDF\x8Bw\x90P_s\xCC\tf\xD8A\x8DA,Y\x9Ad!\xB7`\xA8G\xEB\x16\x9A\x8C\x90P_sI\xB0r\x15\x85d\xDB60E\x18\xFF\xA3{\x1C\xFC\x13\x91j\x90s\xBAF\xFC\xC1kFM\x97\x871Ag\xBD\xD9\xF1\xCE(@[\xA1\x7FVdR\x02@\xA4kK>\x96U\xC2\x0C\xC3\xF9\xE0\x84\x96\xA9\xB7F\xA4x\xE4v\xAE>\x04\xD6\xC8\xFC1\x7Fh\x99\xA7\xE1;e_\xA3g \x8C\xB2|n\xAA$\x107\r\x15e\xDC\x1F_\x11\x85:\x1E\x8C\xBE\xF03\x86\x86`@Qa\x0E\xAE\x90a\x1C\xC8V[`\x01`\x01`\xA0\x1B\x03\x96\x87\x16\x81R\x94\x86\x16` \x86\x01R`@\x85\x01\x93\x90\x93R``\x84\x01\x91\x90\x91R\x83\x16`\x80\x83\x01R\x90\x91\x16`\xA0\x82\x01R`\xC0\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x0E\xFEW=__>=_\xFD[P\x90P_s^\xF2\xB8\xFB\xCC\x8A\xEA*\x9D\xBE')\xF0\xAC\xF3>\x07?\xA4>\x90P_\x81`@Qa\x0F'\x90a\x1C\xAEV[`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x0FPW=__>=_\xFD[P\x90P_\x83\x82`@Qa\x0Fb\x90a\x1C\xD5V[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x0F\x92W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10\x0CW__\xFD[PZ\xF1\x15\x80\x15a\x10\x1EW=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10\x94W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\xB8\x91\x90a FV[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x11?W__\xFD[PZ\xF1\x15\x80\x15a\x11QW=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x11\xA1W__\xFD[PZ\xF1\x15\x80\x15a\x11\xB3W=__>=_\xFD[PP`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01R_\x92P`\x01`\x01`\xA0\x1B\x03\x86\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\xFCW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12 \x91\x90a lV[\x90Pa\x12b\x81_`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01\x7FUser has seTokens\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1B\xD1V[`\x1FT`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01Ra\x12\x9A\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90cp\xA0\x821\x90`$\x01a\x06\x1BV[`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12\xFDW__\xFD[PZ\xF1\x15\x80\x15a\x13\x0FW=__>=_\xFD[PP`@Q\x7F\xDB\0ju\0\0\0\0\0\0\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`\x01`\x01`\xA0\x1B\x03\x87\x16\x92Pc\xDB\0ju\x91P`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x13pW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13\x94\x91\x90a lV[P`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x85\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x13\xD8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13\xFC\x91\x90a lV[\x90Pa\x14>\x81_`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01\x7FUser has redeemed\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1CMV[`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01Ra\t\xEC\x90`\x01`\x01`\xA0\x1B\x03\x88\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x14\x85W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x14\xA9\x91\x90a lV[_`@Q\x80`@\x01`@R\x80`\x1B\x81R` \x01\x7FUser has SolvBTC.BBN tokens\0\0\0\0\0\x81RPa\x1B\xD1V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W\x83\x82\x90_R` _ \x01\x80Ta\x15%\x90a \x9EV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x15Q\x90a \x9EV[\x80\x15a\x15\x9CW\x80`\x1F\x10a\x15sWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x15\x9CV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15\x7FW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x15\x08V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x16\x8EW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x16;W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x15\xD3V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x17\x84W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x171W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x16\xC9V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W\x83\x82\x90_R` _ \x01\x80Ta\x17\xDC\x90a \x9EV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x18\x08\x90a \x9EV[\x80\x15a\x18SW\x80`\x1F\x10a\x18*Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x18SV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x186W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x17\xBFV[`\x08T_\x90`\xFF\x16\x15a\x18~WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x19\x0CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x190\x91\x90a lV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\n\x88W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\njWPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1A0W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x1AW\x91\x90\x81\x01\x90a!\x1CV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1Au\x92\x91\x90a!\xD0V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x1A\x91W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1A\xB5\x91\x90a lV[P`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1B!W__\xFD[PZ\xF1\x15\x80\x15a\x1B3W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x1B\xA6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1B\xCA\x91\x90a FV[PPPPPV[`@Q\x7F\xD9\xA3\xC4\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xD9\xA3\xC4\xD2\x90a\x1C%\x90\x86\x90\x86\x90\x86\x90`\x04\x01a!\xF1V[_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1C;W__\xFD[PZ\xFA\x15\x80\x15a\t\xECW=__>=_\xFD[`@Q\x7F\x88\xB4L\x85\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x88\xB4L\x85\x90a\x1C%\x90\x86\x90\x86\x90\x86\x90`\x04\x01a!\xF1V[a\x0C\xD4\x80a\"\x19\x839\x01\x90V[a\x0C\xC6\x80a.\xED\x839\x01\x90V[a\r\x8C\x80a;\xB3\x839\x01\x90V[a\x0F-\x80aI?\x839\x01\x90V[a\r \x80aXl\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1D\"W\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1C\xFBV[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1E6W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`\x01`\x01`\xA0\x1B\x03\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x1E\x1CW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x1E\x06\x84\x86Qa\x1D-V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x1D\xCCV[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x1D\x81V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x1E\x94W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x1ETV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1E6W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x1E\xEA`@\x88\x01\x82a\x1D-V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x1F\x05\x81\x83a\x1EBV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1E\xC4V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1E6W`?\x19\x87\x86\x03\x01\x84Ra\x1F^\x85\x83Qa\x1D-V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1FBV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1E6W`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1F\xD4`@\x87\x01\x82a\x1EBV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1F\x99V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x1F\xFEW__\xFD[PV[____`\x80\x85\x87\x03\x12\x15a \x14W__\xFD[\x845\x93P` \x85\x015a &\x81a\x1F\xEAV[\x92P`@\x85\x015a 6\x81a\x1F\xEAV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[_` \x82\x84\x03\x12\x15a VW__\xFD[\x81Q\x80\x15\x15\x81\x14a eW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a |W__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a \x93W__\xFD[\x81Qa e\x81a\x1F\xEAV[`\x01\x81\x81\x1C\x90\x82\x16\x80a \xB2W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a \xE9W\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[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!,W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a!BW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a!RW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a!lWa!la \xEFV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a!\x9CWa!\x9Ca \xEFV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a!\xB3W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a!\xE2`@\x83\x01\x85a\x1D-V[\x90P\x82` \x83\x01R\x93\x92PPPV[\x83\x81R\x82` \x82\x01R```@\x82\x01R_a\"\x0F``\x83\x01\x84a\x1D-V[\x95\x94PPPPPV\xFE`\xA0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x0C\xD48\x03\x80a\x0C\xD4\x839\x81\x01`@\x81\x90Ra\0.\x91a\0?V[`\x01`\x01`\xA0\x1B\x03\x16`\x80Ra\0lV[_` \x82\x84\x03\x12\x15a\0OW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0eW__\xFD[\x93\x92PPPV[`\x80Qa\x0C=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02UW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02y\x91\x90a\x0B,V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xE6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\n\x91\x90a\x0BGV[\x83Q\x90\x91P\x81\x10\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\x9Es\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x85\x83a\x05\xB4V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xB3\x90\x85\x90\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\x90`\x84\x01[`@\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\x0FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05-W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05Q\x91\x90a\x0BGV[a\x05[\x91\x90a\x0B^V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xB3\x90\x85\x90\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\x90`d\x01a\x04OV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x06\n\x90\x84\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\x90`d\x01a\x04OV[PPPV[_a\x06p\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\x07\x1A\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\nW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x8E\x91\x90a\x0B\x9CV[a\x06\nW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[``a\x07(\x84\x84_\x85a\x072V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xC4W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08BW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[__\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\x08j\x91\x90a\x0B\xBBV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xA4W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xA9V[``\x91P[P\x91P\x91Pa\x08\xB9\x82\x82\x86a\x08\xC4V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xD3WP\x81a\x07+V[\x82Q\x15a\x08\xE3W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03t\x91\x90a\x0B\xD1V[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\t8W__\xFD[PV[\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\x8BWa\t\x8Ba\t;V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xBAWa\t\xBAa\t;V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xD5W__\xFD[\x845a\t\xE0\x81a\t\x17V[\x93P` \x85\x015\x92P`@\x85\x015a\t\xF7\x81a\t\x17V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x12W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\"W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nz9,\xA4\xD4K\x0C\x1B\x8D=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xFA\x91\x90a\x0B\x1EV[`@Q\x7F#2>\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x88\x90R\x91\x92P_\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\x90c#2>\x03\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02\x91W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xB5\x91\x90a\x0B\x1EV[\x90P\x80\x15a\x03\nW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FCould not mint token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@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\x86\x81\x16`\x04\x83\x01R_\x91\x90\x85\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03wW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x9B\x91\x90a\x0B\x1EV[\x90P\x82\x81\x11a\x03\xECW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[_a\x03\xF7\x84\x83a\x0BbV[\x86Q\x90\x91P\x81\x10\x15a\x04KW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05c\x90\x85\x90\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\x90`\x84\x01[`@\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\x06dV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xDDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x01\x91\x90a\x0B\x1EV[a\x06\x0B\x91\x90a\x0B{V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05c\x90\x85\x90\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\x90`d\x01a\x04\xFFV[_a\x06\xC5\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\x07Z\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07UW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xE3\x91\x90a\x0B\x8EV[a\x07UW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[PPPV[``a\x07h\x84\x84_\x85a\x07rV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xEAW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08NW`@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\x03\x01V[__\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\x08v\x91\x90a\x0B\xADV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB0W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB5V[``\x91P[P\x91P\x91Pa\x08\xC5\x82\x82\x86a\x08\xD0V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xDFWP\x81a\x07kV[\x82Q\x15a\x08\xEFW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\x01\x91\x90a\x0B\xC3V[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\t*W__\xFD[PV[\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}Wa\t}a\t-V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xACWa\t\xACa\t-V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xC7W__\xFD[\x845a\t\xD2\x81a\t\tV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xE9\x81a\t\tV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x04W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x14W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n.Wa\n.a\t-V[a\nA` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x83V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nUW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x8AW__\xFD[\x855a\n\x95\x81a\t\tV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xAC\x81a\t\tV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xDDW__\xFD[Pa\n\xE6a\tZV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x0BW__\xFD[Pa\x0B\x14a\tZV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B.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`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x0BuWa\x0Bua\x0B5V[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0BuWa\x0Bua\x0B5V[_` \x82\x84\x03\x12\x15a\x0B\x9EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07kW__\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\xFE\xA2dipfsX\"\x12 \x96\xEFe\xB7\x9F\r\x80\x90U\x93\x15 \xD9\x88!\x13\xA9\xD5\xB6{=\xE4\xB8guk\xD84\x96\x11p%dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\x8C8\x03\x80a\r\x8C\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\xB6a\0\xD6_9_\x81\x81`\xCB\x01R\x81\x81a\x03\xE1\x01Ra\x04a\x01R_\x81\x81`S\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0C\xB6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c#\x17\x10\xA5\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xB0\xF1\xE3u\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\n=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFB\xFAw\xCF`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B\xA6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x0EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x032\x91\x90a\x0B\xA6V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xC3\x91\x90a\x0B\xC1V[\x90Pa\x04\x06s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x84V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xA2W__\xFD[PZ\xF1\x15\x80\x15a\x04\xB4W=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05~\x90\x85\x90\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\x90`\x84\x01[`@\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\x7FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1C\x91\x90a\x0B\xC1V[a\x06&\x91\x90a\x0B\xD8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05~\x90\x85\x90\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\x90`d\x01a\x05\x1AV[_a\x06\xE0\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\x07\x94\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\x8FW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFE\x91\x90a\x0C\x16V[a\x07\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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x07\xA2\x84\x84_\x85a\x07\xACV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08>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\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\x07\x86V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\xBCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x86V[__\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\x08\xE4\x91\x90a\x0C5V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\t\x1EW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t#V[``\x91P[P\x91P\x91Pa\t3\x82\x82\x86a\t>V[\x97\x96PPPPPPPV[``\x83\x15a\tMWP\x81a\x07\xA5V[\x82Q\x15a\t]W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x86\x91\x90a\x0CKV[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\t\xB2W__\xFD[PV[\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\n\x05Wa\n\x05a\t\xB5V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n4Wa\n4a\t\xB5V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\nOW__\xFD[\x845a\nZ\x81a\t\x91V[\x93P` \x85\x015\x92P`@\x85\x015a\nq\x81a\t\x91V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x8CW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x9CW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xB6Wa\n\xB6a\t\xB5V[a\n\xC9` `\x1F\x19`\x1F\x84\x01\x16\x01a\n\x0BV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n\xDDW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0B\x12W__\xFD[\x855a\x0B\x1D\x81a\t\x91V[\x94P` \x86\x015\x93P`@\x86\x015a\x0B4\x81a\t\x91V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0BeW__\xFD[Pa\x0Bna\t\xE2V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x93W__\xFD[Pa\x0B\x9Ca\t\xE2V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xB6W__\xFD[\x81Qa\x07\xA5\x81a\t\x91V[_` \x82\x84\x03\x12\x15a\x0B\xD1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0C\x10W\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[_` \x82\x84\x03\x12\x15a\x0C&W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\xA5W__\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\xFE\xA2dipfsX\"\x12 \xC8o\xCDB\x03\x85\xE3\xD8\xE52\x96F\x87\xCC\x1Eo\xE7\xC4i\x88\x13fC'6\x1Dq);\xA3\xF6ydsolcC\0\x08\x1C\x003a\x01@`@R4\x80\x15a\0\x10W__\xFD[P`@Qa\x0F-8\x03\x80a\x0F-\x839\x81\x01`@\x81\x90Ra\0/\x91a\0sV[`\x01`\x01`\xA0\x1B\x03\x95\x86\x16`\x80R\x93\x85\x16`\xA0R`\xC0\x92\x90\x92R`\xE0R\x82\x16a\x01\0R\x16a\x01 Ra\0\xE3V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0pW__\xFD[PV[______`\xC0\x87\x89\x03\x12\x15a\0\x88W__\xFD[\x86Qa\0\x93\x81a\0\\V[` \x88\x01Q\x90\x96Pa\0\xA4\x81a\0\\V[`@\x88\x01Q``\x89\x01Q`\x80\x8A\x01Q\x92\x97P\x90\x95P\x93Pa\0\xC4\x81a\0\\V[`\xA0\x88\x01Q\x90\x92Pa\0\xD5\x81a\0\\V[\x80\x91PP\x92\x95P\x92\x95P\x92\x95V[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\r\xC6a\x01g_9_\x81\x81a\x01.\x01R\x81\x81a\x04\xFC\x01Ra\x05>\x01R_\x81\x81a\x01U\x01Ra\x03R\x01R_\x81\x81a\x01\xB1\x01Ra\x03\xC1\x01R_\x81\x81a\x01|\x01Ra\x02\x88\x01R_\x81\x81`\xDF\x01R\x81\x81a\x03t\x01Ra\x03\xF0\x01R_\x81\x81`\x8E\x01R\x81\x81a\x02;\x01Ra\x02\xB7\x01Ra\r\xC6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\x85W_5`\xE0\x1C\x80c\xADt}\xE6\x11a\0XW\x80c\xADt}\xE6\x14a\x01)W\x80c\xB9\x93|\xCB\x14a\x01PW\x80c\xC8\xC7\xF7\x01\x14a\x01wW\x80c\xE3L\xEF\x86\x14a\x01\xACW__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0\x89W\x80cN=\xF3\xF4\x14a\0\xDAW\x80cPcL\x0E\x14a\x01\x01W\x80c\x7F\x81O5\x14a\x01\x16W[__\xFD[a\0\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\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\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\x81V[a\x01\x14a\x01\x0F6`\x04a\x0BgV[a\x01\xD3V[\0[a\x01\x14a\x01$6`\x04a\x0C)V[a\x01\xFDV[a\0\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\x81V[a\0\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\x81V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xD1V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\xE8\x91\x90a\x0C\xADV[\x90Pa\x01\xF6\x85\x85\x85\x84a\x01\xFDV[PPPPPV[a\x02\x1Fs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x9AV[a\x02`s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x036\x91\x90a\x0C\xD1V[\x90Pa\x03\x99s\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\x7F\0\0\0\0\0\0\0\0\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\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x82\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04KW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04o\x91\x90a\x0C\xD1V[\x83Q\x90\x91P\x81\x10\x15a\x04\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[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\x85\x83a\x07YV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x06X\x90\x85\x90\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\x90`\x84\x01[`@\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\x07\xB4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF6\x91\x90a\x0C\xD1V[a\x07\0\x91\x90a\x0C\xE8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x06X\x90\x85\x90\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\x90`d\x01a\x05\xF4V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07\xAF\x90\x84\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\x90`d\x01a\x05\xF4V[PPPV[_a\x08\x15\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\x08\xBF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\xAFW\x80\x80` \x01\x90Q\x81\x01\x90a\x083\x91\x90a\r&V[a\x07\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\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\x04\xD9V[``a\x08\xCD\x84\x84_\x85a\x08\xD7V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\tiW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x04\xD9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\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`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x04\xD9V[__\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\n\x0F\x91\x90a\rEV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\nIW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\nNV[``\x91P[P\x91P\x91Pa\n^\x82\x82\x86a\niV[\x97\x96PPPPPPPV[``\x83\x15a\nxWP\x81a\x08\xD0V[\x82Q\x15a\n\x88W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x04\xD9\x91\x90a\r[V[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\xDDW__\xFD[PV[\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\x0B0Wa\x0B0a\n\xE0V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0B_Wa\x0B_a\n\xE0V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0BzW__\xFD[\x845a\x0B\x85\x81a\n\xBCV[\x93P` \x85\x015\x92P`@\x85\x015a\x0B\x9C\x81a\n\xBCV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xB7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\x0B\xC7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xE1Wa\x0B\xE1a\n\xE0V[a\x0B\xF4` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0B6V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0C\x08W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0C=W__\xFD[\x855a\x0CH\x81a\n\xBCV[\x94P` \x86\x015\x93P`@\x86\x015a\x0C_\x81a\n\xBCV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0C\x90W__\xFD[Pa\x0C\x99a\x0B\rV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0C\xBEW__\xFD[Pa\x0C\xC7a\x0B\rV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C\xE1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\r 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[_` \x82\x84\x03\x12\x15a\r6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x08\xD0W__\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\xFE\xA2dipfsX\"\x12 \xD28\x8C\xB3\xDCz\xA6\xF5\xA2\xEBuA}\x11\x05\x9B\xE1<\x8C\x9E\xAB\xE5\xD7\xEA\xDB\x1BV\x1F\x93\x7F\xF6\x91dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r 8\x03\x80a\r \x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CJa\0\xD6_9_\x81\x81`{\x01R\x81\x81a\x03u\x01Ra\x03\xF5\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0CJ_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cPcL\x0E\x14a\0NW\x80c\x7F\x81O5\x14a\0cW\x80c\xB0\xF1\xE3u\x14a\0vW\x80c\xF2#L\xF9\x14a\0\xC6W[__\xFD[a\0aa\0\\6`\x04a\t\xD0V[a\0\xEDV[\0[a\0aa\0q6`\x04a\n\x92V[a\x01\x17V[a\0\x9D\x7F\0\0\0\0\0\0\0\0\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\x9D\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 \"\x8F\x03\x84\x07\x19t\xAAf\xF7u\xC6\x06\xB7\xDD\x8B\x8AKq\xA1\x9E<9!\xA2\xDD\xC4}\xE1\xC4\xDAcdsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 Ro.\xA5\xB6\x05\xF8m\x98\x0B\x9Cn\x962\xA2\xC4h\x14\xCB\xAF\x88\xEB\x14})\xE6\xFEc \x1E\xA5\xF9dsolcC\0\x08\x1C\x003", ); /// 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\x01\x8FW_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\xDDW\x80c\xD2\xAD\xDB\xB8\x11a\0\x88W\x80c\xF3\xAC%\x0C\x11a\0cW\x80c\xF3\xAC%\x0C\x14a\x02\xDFW\x80c\xFAv&\xD4\x14a\x02\xE7W\x80c\xFA\xD0k\x8F\x14a\x02\xF4W__\xFD[\x80c\xD2\xAD\xDB\xB8\x14a\x02\xC7W\x80c\xDB\x84\xFC\x88\x14a\x02\xCFW\x80c\xE2\x0C\x9Fq\x14a\x02\xD7W__\xFD[\x80c\xB0FO\xDC\x11a\0\xB8W\x80c\xB0FO\xDC\x14a\x02\x9FW\x80c\xB5P\x8A\xA9\x14a\x02\xA7W\x80c\xBAAO\xA6\x14a\x02\xAFW__\xFD[\x80c\x91j\x17\xC6\x14a\x02zW\x80c\x96\xA7\x8Dw\x14a\x02\x8FW\x80c\x97\xEC6\xE9\x14a\x02\x97W__\xFD[\x80c?r\x86\xF4\x11a\x01=W\x80cf\xD9\xA9\xA0\x11a\x01\x18W\x80cf\xD9\xA9\xA0\x14a\x02HW\x80c\x82}}\xB1\x14a\x02]W\x80c\x85\"l\x81\x14a\x02eW__\xFD[\x80c?r\x86\xF4\x14a\x02\x18W\x80cD\xBA\xDB\xB6\x14a\x02 W\x80ca\xAC\x80\x13\x14a\x02@W__\xFD[\x80c\x1E\xD7\x83\x1C\x11a\x01mW\x80c\x1E\xD7\x83\x1C\x14a\x01\xE6W\x80c*\xDE8\x80\x14a\x01\xFBW\x80c>^<#\x14a\x02\x10W__\xFD[\x80c\x08\x13\x85*\x14a\x01\x93W\x80c\x18\xAA\xE3l\x14a\x01\xBCW\x80c\x1C\r\xA8\x1F\x14a\x01\xC6W[__\xFD[a\x01\xA6a\x01\xA16`\x04a\x1D\xF9V[a\x03\x07V[`@Qa\x01\xB3\x91\x90a\x1E\xAEV[`@Q\x80\x91\x03\x90\xF3[a\x01\xC4a\x03RV[\0[a\x01\xD9a\x01\xD46`\x04a\x1D\xF9V[a\x04\xB0V[`@Qa\x01\xB3\x91\x90a\x1F\x11V[a\x01\xEEa\x05\"V[`@Qa\x01\xB3\x91\x90a\x1F#V[a\x02\x03a\x05\x82V[`@Qa\x01\xB3\x91\x90a\x1F\xC8V[a\x01\xEEa\x06\xBEV[a\x01\xEEa\x07\x1CV[a\x023a\x02.6`\x04a\x1D\xF9V[a\x07zV[`@Qa\x01\xB3\x91\x90a ?V[a\x01\xC4a\x07\xBDV[a\x02Pa\x08\xB3V[`@Qa\x01\xB3\x91\x90a \xD2V[a\x01\xC4a\n,V[a\x02ma\x0BWV[`@Qa\x01\xB3\x91\x90a!PV[a\x02\x82a\x0C\"V[`@Qa\x01\xB3\x91\x90a!bV[a\x01\xC4a\r\x18V[a\x01\xC4a\x0E\x0BV[a\x02\x82a\x0F\x10V[a\x02ma\x10\x06V[a\x02\xB7a\x10\xD1V[`@Q\x90\x15\x15\x81R` \x01a\x01\xB3V[a\x01\xC4a\x11\xA1V[a\x01\xC4a\x12\x0BV[a\x01\xEEa\x15\xC7V[a\x01\xC4a\x16%V[`\x1FTa\x02\xB7\x90`\xFF\x16\x81V[a\x023a\x03\x026`\x04a\x1D\xF9V[a\x17\x0EV[``a\x03J\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x17QV[\x94\x93PPPPV[sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\xF2\x8D\xCE\xB3`@Q\x80``\x01`@R\x80`0\x81R` \x01a%\xDF`0\x919`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x03\xAA\x91\x90a\x1F\x11V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x03\xC1W__\xFD[PZ\xF1\x15\x80\x15a\x03\xD3W=__>=_\xFD[PPPP`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16c\xB2[\x9B\0`\"`\x03\x81T\x81\x10a\x04\x0FWa\x04\x0Fa!\xD9V[\x90_R` _ \x01T`#`\x04\x81T\x81\x10a\x04,Wa\x04,a!\xD9V[\x90_R` _ \x01`#`\x02\x81T\x81\x10a\x04HWa\x04Ha!\xD9V[\x90_R` _ \x01`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x04n\x93\x92\x91\x90a#,V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04\x89W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04\xAD\x91\x90a#`V[PV[``_a\x04\xBE\x85\x85\x85a\x03\x07V[\x90P_[a\x04\xCC\x85\x85a#\xA4V[\x81\x10\x15a\x05\x19W\x82\x82\x82\x81Q\x81\x10a\x04\xE6Wa\x04\xE6a!\xD9V[` \x02` \x01\x01Q`@Q` \x01a\x04\xFF\x92\x91\x90a#\xCEV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x04\xC2V[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x05xW` \x02\x82\x01\x91\x90_R` _ \x90[\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x05ZW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06\xB5W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x06\x9EW\x83\x82\x90_R` _ \x01\x80Ta\x06\x13\x90a\"\x06V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06?\x90a\"\x06V[\x80\x15a\x06\x8AW\x80`\x1F\x10a\x06aWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x06\x8AV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x06mW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x05\xF6V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05\xA5V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x05xW` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x05ZWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x05xW` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x05ZWPPPPP\x90P\x90V[``a\x03J\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x18(V[sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\xF2\x8D\xCE\xB3`@Q\x80``\x01`@R\x80`0\x81R` \x01a%\xDF`0\x919`@Q\x82c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x08\x15\x91\x90a\x1F\x11V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08,W__\xFD[PZ\xF1\x15\x80\x15a\x08>W=__>=_\xFD[PPPP`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16c\xB2[\x9B\0`\"`\x03\x81T\x81\x10a\x08zWa\x08za!\xD9V[\x90_R` _ \x01T`#`\x02\x81T\x81\x10a\x08\x97Wa\x08\x97a!\xD9V[\x90_R` _ \x01`#`\x04\x81T\x81\x10a\x04HWa\x04Ha!\xD9V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06\xB5W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\t\x06\x90a\"\x06V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\t2\x90a\"\x06V[\x80\x15a\t}W\x80`\x1F\x10a\tTWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\t}V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t`W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\n\x14W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\t\xC1W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x08\xD6V[`@\x80Q\x80\x82\x01\x82R`\r\x81R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\n\xAD\x91\x90`\x04\x01a\x1F\x11V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\n\xC4W__\xFD[PZ\xF1\x15\x80\x15a\n\xD6W=__>=_\xFD[PPPP`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16c\xB2[\x9B\0`\"`\x03\x81T\x81\x10a\x0B\x12Wa\x0B\x12a!\xD9V[\x90_R` _ \x01T`#`\x04\x81T\x81\x10a\x0B/Wa\x0B/a!\xD9V[\x90_R` _ \x01`'`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x04n\x93\x92\x91\x90a#,V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06\xB5W\x83\x82\x90_R` _ \x01\x80Ta\x0B\x97\x90a\"\x06V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\xC3\x90a\"\x06V[\x80\x15a\x0C\x0EW\x80`\x1F\x10a\x0B\xE5Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C\x0EV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xF1W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0BzV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06\xB5W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\0W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C\xADW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0CEV[`\x1FT`\"\x80Ta\x0E\t\x92a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x91c\xB2[\x9B\0\x91`\x03\x90\x81\x10a\rIWa\rIa!\xD9V[\x90_R` _ \x01T`#`\x04\x81T\x81\x10a\rfWa\rfa!\xD9V[\x90_R` _ \x01`#`\x05\x81T\x81\x10a\r\x82Wa\r\x82a!\xD9V[\x90_R` _ \x01`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\r\xA8\x93\x92\x91\x90a#,V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\r\xC3W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\xE7\x91\x90a#`V[`\"`\x05\x81T\x81\x10a\r\xFBWa\r\xFBa!\xD9V[\x90_R` _ \x01Ta\x18\xECV[V[`@\x80Q\x80\x82\x01\x82R`\r\x81R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x0E\x8C\x91\x90`\x04\x01a\x1F\x11V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0E\xA3W__\xFD[PZ\xF1\x15\x80\x15a\x0E\xB5W=__>=_\xFD[PPPP`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16c\xB2[\x9B\0`\"`\x03\x81T\x81\x10a\x0E\xF1Wa\x0E\xF1a!\xD9V[\x90_R` _ \x01T`'`#`\x04\x81T\x81\x10a\x04HWa\x04Ha!\xD9V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06\xB5W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0F\xEEW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0F\x9BW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0F3V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x06\xB5W\x83\x82\x90_R` _ \x01\x80Ta\x10F\x90a\"\x06V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x10r\x90a\"\x06V[\x80\x15a\x10\xBDW\x80`\x1F\x10a\x10\x94Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x10\xBDV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x10\xA0W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x10)V[`\x08T_\x90`\xFF\x16\x15a\x10\xE8WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11vW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\x9A\x91\x90a#`V[\x14\x15\x90P\x90V[`\x1FT`\"\x80Ta\x0E\t\x92a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x91c\xB2[\x9B\0\x91`\x03\x90\x81\x10a\x11\xD2Wa\x11\xD2a!\xD9V[\x90_R` _ \x01T`#`\x05\x81T\x81\x10a\x11\xEFWa\x11\xEFa!\xD9V[\x90_R` _ \x01`#`\x04\x81T\x81\x10a\r\x82Wa\r\x82a!\xD9V[_a\x12\xDC`@Q\x80`@\x01`@R\x80`\x18\x81R` \x01\x7F.orphan_562630.digest_le\0\0\0\0\0\0\0\0\x81RP` \x80Ta\x12R\x90a\"\x06V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x12~\x90a\"\x06V[\x80\x15a\x12\xC9W\x80`\x1F\x10a\x12\xA0Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x12\xC9V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x12\xACW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x19o\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90P_a\x13\xAF`@Q\x80`@\x01`@R\x80`\x12\x81R` \x01\x7F.orphan_562630.hex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RP` \x80Ta\x13%\x90a\"\x06V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x13Q\x90a\"\x06V[\x80\x15a\x13\x9CW\x80`\x1F\x10a\x13sWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x13\x9CV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x13\x7FW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x1A\x0B\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x90P_a\x13\xFA`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01\x7Fchain\0\0\0\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`\x08\x80`\x01a\x02.\x91\x90a#\xE2V[_\x81Q\x81\x10a\x14\x0BWa\x14\x0Ba!\xD9V[` \x02` \x01\x01Q\x90P_a\x14^`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01\x7Fchain\0\0\0\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`\x08\x80`\x01a\x01\xA1\x91\x90a#\xE2V[_\x81Q\x81\x10a\x14oWa\x14oa!\xD9V[` \x02` \x01\x01Q\x90Pa\x15\"`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16c\xB2[\x9B\0`\"`\x03\x81T\x81\x10a\x14\xB4Wa\x14\xB4a!\xD9V[\x90_R` _ \x01T\x84\x87`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x14\xDD\x93\x92\x91\x90a#\xF5V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x14\xF8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x15\x1C\x91\x90a#`V[\x83a\x18\xECV[`\x1FT`\"\x80Ta\x15\xC1\x92a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x91c\xB2[\x9B\0\x91`\x03\x90\x81\x10a\x15SWa\x15Sa!\xD9V[\x90_R` _ \x01T\x86\x85`@Q\x84c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x15|\x93\x92\x91\x90a#\xF5V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x15\x97W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x15\xBB\x91\x90a#`V[\x85a\x18\xECV[PPPPV[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x05xW` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x05ZWPPPPP\x90P\x90V[`@\x80Q\x80\x82\x01\x82R`\r\x81R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0` \x82\x01R\x90Q\x7F\xF2\x8D\xCE\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x91c\xF2\x8D\xCE\xB3\x91a\x16\xA6\x91\x90`\x04\x01a\x1F\x11V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x16\xBDW__\xFD[PZ\xF1\x15\x80\x15a\x16\xCFW=__>=_\xFD[PPPP`\x1F`\x01\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`\xA0\x1B\x03\x16`\x01`\x01`\xA0\x1B\x03\x16c\xB2[\x9B\0`&T`#`\x03\x81T\x81\x10a\x08\x97Wa\x08\x97a!\xD9V[``a\x03J\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1A\xA1V[``a\x17]\x84\x84a#\xA4V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17uWa\x17ua\x1DtV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x17\xA8W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x17\x93W\x90P[P\x90P\x83[\x83\x81\x10\x15a\x18\x1FWa\x17\xF1\x86a\x17\xC2\x83a\x1B\xEFV[\x85`@Q` \x01a\x17\xD5\x93\x92\x91\x90a$\x1FV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x13%\x90a\"\x06V[\x82a\x17\xFC\x87\x84a#\xA4V[\x81Q\x81\x10a\x18\x0CWa\x18\x0Ca!\xD9V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x17\xADV[P\x94\x93PPPPV[``a\x184\x84\x84a#\xA4V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18LWa\x18La\x1DtV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x18uW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x18\x1FWa\x18\xBE\x86a\x18\x8F\x83a\x1B\xEFV[\x85`@Q` \x01a\x18\xA2\x93\x92\x91\x90a$\x1FV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x12R\x90a\"\x06V[\x82a\x18\xC9\x87\x84a#\xA4V[\x81Q\x81\x10a\x18\xD9Wa\x18\xD9a!\xD9V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x18zV[`@Q\x7F|\x84\xC6\x9B\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c|\x84\xC6\x9B\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x19UW__\xFD[PZ\xFA\x15\x80\x15a\x19gW=__>=_\xFD[PPPPPPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x19\xC3\x90\x86\x90\x86\x90`\x04\x01a$\xB2V[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x19\xDEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1A\x02\x91\x90a#`V[\x90P[\x92\x91PPV[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a\x1A`\x90\x86\x90\x86\x90`\x04\x01a$\xB2V[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1AzW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x1A\x02\x91\x90\x81\x01\x90a$\xDFV[``a\x1A\xAD\x84\x84a#\xA4V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1A\xC5Wa\x1A\xC5a\x1DtV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x1A\xEEW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\x18\x1FWa\x1B\xC1\x86a\x1B\x08\x83a\x1B\xEFV[\x85`@Q` \x01a\x1B\x1B\x93\x92\x91\x90a$\x1FV[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x1B7\x90a\"\x06V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x1Bc\x90a\"\x06V[\x80\x15a\x1B\xAEW\x80`\x1F\x10a\x1B\x85Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x1B\xAEV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x1B\x91W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x1D \x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x1B\xCC\x87\x84a#\xA4V[\x81Q\x81\x10a\x1B\xDCWa\x1B\xDCa!\xD9V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x1A\xF3V[``\x81_\x03a\x1C1WPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x1CZW\x80a\x1CD\x81a%TV[\x91Pa\x1CS\x90P`\n\x83a%\xB8V[\x91Pa\x1C4V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1CtWa\x1Cta\x1DtV[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x1C\x9EW` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x03JWa\x1C\xB3`\x01\x83a#\xA4V[\x91Pa\x1C\xC0`\n\x86a%\xCBV[a\x1C\xCB\x90`0a#\xE2V[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x1C\xE0Wa\x1C\xE0a!\xD9V[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x1D\x19`\n\x86a%\xB8V[\x94Pa\x1C\xA2V[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x19\xC3\x90\x86\x90\x86\x90`\x04\x01a$\xB2V[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x1D\xCAWa\x1D\xCAa\x1DtV[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x1D\xEBWa\x1D\xEBa\x1DtV[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x1E\x0BW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E!W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x1E1W__\xFD[\x805a\x1EDa\x1E?\x82a\x1D\xD2V[a\x1D\xA1V[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x1EXW__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1F\x05W`?\x19\x87\x86\x03\x01\x84Ra\x1E\xF0\x85\x83Qa\x1E\x80V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1E\xD4V[P\x92\x96\x95PPPPPPV[` \x81R_a\x1A\x02` \x83\x01\x84a\x1E\x80V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1FcW\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1F^<#\x11a\0\xE8W\x80c>^<#\x14a\x01]W\x80c?r\x86\xF4\x14a\x01eW\x80cf\xD9\xA9\xA0\x14a\x01mW\x80ck9d\x13\x14a\x01\x82W__\xFD[\x80b?+\x1D\x14a\x01\x18W\x80c\n\x92T\xE4\x14a\x01\"W\x80c\x1E\xD7\x83\x1C\x14a\x01*W\x80c*\xDE8\x80\x14a\x01HW[__\xFD[a\x01 a\x024V[\0[a\x01 a\t\xF5V[a\x012a\n2V[`@Qa\x01?\x91\x90a\x1C\xE2V[`@Q\x80\x91\x03\x90\xF3[a\x01Pa\n\x92V[`@Qa\x01?\x91\x90a\x1D[V[a\x012a\x0B\xCEV[a\x012a\x0C,V[a\x01ua\x0C\x8AV[`@Qa\x01?\x91\x90a\x1E\x9EV[a\x01 a\x0E\x03V[a\x01\x92a\x14\xE5V[`@Qa\x01?\x91\x90a\x1F\x1CV[a\x01\xA7a\x15\xB0V[`@Qa\x01?\x91\x90a\x1FsV[a\x01\xA7a\x16\xA6V[a\x01\x92a\x17\x9CV[a\x01\xCCa\x18gV[`@Q\x90\x15\x15\x81R` \x01a\x01?V[a\x012a\x197V[a\x01 a\x01\xF26`\x04a \x01V[a\x19\x95V[`\x1FTa\x01\xCC\x90`\xFF\x16\x81V[`\x1FTa\x02\x1C\x90a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01?V[_s*\xC9\x8D\xB4\x1C\xBD1r\xCB{\x8F\xD8\xA8\xAB;\x91\xCF\xE4]\xCF\x90P_\x81`@Qa\x02Z\x90a\x1C\xA1V[`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x02\x83W=__>=_\xFD[P\x90P_sxH\xF0w^\xEB\xAB\xBFU\xCBtI\x0C\xE6\xD3g>hw:\x90P_\x81`@Qa\x02\xAC\x90a\x1C\xAEV[`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x02\xD5W=__>=_\xFD[P\x90P_\x83\x82`@Qa\x02\xE7\x90a\x1C\xBBV[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03\x17W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x03\x91W__\xFD[PZ\xF1\x15\x80\x15a\x03\xA3W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04\x19W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04=\x91\x90a FV[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xC4W__\xFD[PZ\xF1\x15\x80\x15a\x04\xD6W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05&W__\xFD[PZ\xF1\x15\x80\x15a\x058W=__>=_\xFD[PP`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01R_\x92P`\x01`\x01`\xA0\x1B\x03\x86\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x81W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xA5\x91\x90a lV[\x90Pa\x05\xE7\x81_`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01\x7FUser has seTokens\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1B\xD1V[`\x1FT`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01Ra\x06\x96\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90cp\xA0\x821\x90`$\x01[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x066W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06Z\x91\x90a lV[_`@Q\x80`@\x01`@R\x80`\x17\x81R` \x01\x7FUser has no WBTC tokens\0\0\0\0\0\0\0\0\0\x81RPa\x1CMV[_\x86`\x01`\x01`\xA0\x1B\x03\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD3W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF7\x91\x90a \x83V[`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01R\x90\x91Pa\x07\xA1\x90`\x01`\x01`\xA0\x1B\x03\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07AW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07e\x91\x90a lV[_`@Q\x80`@\x01`@R\x80`\x19\x81R` \x01\x7FUser has no uniBTC tokens\0\0\0\0\0\0\0\x81RPa\x1CMV[`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\x04W__\xFD[PZ\xF1\x15\x80\x15a\x08\x16W=__>=_\xFD[PP`@Q\x7F\xDB\0ju\0\0\0\0\0\0\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`\x01`\xA0\x1B\x03\x88\x16\x92Pc\xDB\0ju\x91P`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x08wW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\x9B\x91\x90a lV[P`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x86\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\xDFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\x03\x91\x90a lV[\x91Pa\tE\x82_`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01\x7FUser has redeemed\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1CMV[`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01Ra\t\xEC\x90`\x01`\x01`\xA0\x1B\x03\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\t\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\xB0\x91\x90a lV[_`@Q\x80`@\x01`@R\x80`\x1F\x81R` \x01\x7FUser increase in uniBTC Balance\0\x81RPa\x1B\xD1V[PPPPPPPV[a\n0bi\xFC\x8AsZ\x8E\x97t\xD6\x7F\xE8F\xC6\xF41\x1C\x07>*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x19\x95V[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\n\x88W` \x02\x82\x01\x91\x90_R` _ \x90[\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\njW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x0B\xAEW\x83\x82\x90_R` _ \x01\x80Ta\x0B#\x90a \x9EV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0BO\x90a \x9EV[\x80\x15a\x0B\x9AW\x80`\x1F\x10a\x0BqWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\x9AV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B}W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0B\x06V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\n\xB5V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\n\x88W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\njWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\n\x88W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\njWPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x0C\xDD\x90a \x9EV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\t\x90a \x9EV[\x80\x15a\rTW\x80`\x1F\x10a\r+Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rTV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r7W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\r\xEBW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\x98W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xADV[_sT\x1F\xD7IA\x9C\xA8\x06\xA8\xBC}\xA8\xAC#\xD3F\xF2\xDF\x8Bw\x90P_s\xCC\tf\xD8A\x8DA,Y\x9Ad!\xB7`\xA8G\xEB\x16\x9A\x8C\x90P_sI\xB0r\x15\x85d\xDB60E\x18\xFF\xA3{\x1C\xFC\x13\x91j\x90s\xBAF\xFC\xC1kFM\x97\x871Ag\xBD\xD9\xF1\xCE(@[\xA1\x7FVdR\x02@\xA4kK>\x96U\xC2\x0C\xC3\xF9\xE0\x84\x96\xA9\xB7F\xA4x\xE4v\xAE>\x04\xD6\xC8\xFC1\x7Fh\x99\xA7\xE1;e_\xA3g \x8C\xB2|n\xAA$\x107\r\x15e\xDC\x1F_\x11\x85:\x1E\x8C\xBE\xF03\x86\x86`@Qa\x0E\xAE\x90a\x1C\xC8V[`\x01`\x01`\xA0\x1B\x03\x96\x87\x16\x81R\x94\x86\x16` \x86\x01R`@\x85\x01\x93\x90\x93R``\x84\x01\x91\x90\x91R\x83\x16`\x80\x83\x01R\x90\x91\x16`\xA0\x82\x01R`\xC0\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x0E\xFEW=__>=_\xFD[P\x90P_s^\xF2\xB8\xFB\xCC\x8A\xEA*\x9D\xBE')\xF0\xAC\xF3>\x07?\xA4>\x90P_\x81`@Qa\x0F'\x90a\x1C\xAEV[`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x0FPW=__>=_\xFD[P\x90P_\x83\x82`@Qa\x0Fb\x90a\x1C\xD5V[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x0F\x92W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10\x0CW__\xFD[PZ\xF1\x15\x80\x15a\x10\x1EW=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10\x94W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\xB8\x91\x90a FV[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x11?W__\xFD[PZ\xF1\x15\x80\x15a\x11QW=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x11\xA1W__\xFD[PZ\xF1\x15\x80\x15a\x11\xB3W=__>=_\xFD[PP`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01R_\x92P`\x01`\x01`\xA0\x1B\x03\x86\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\xFCW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12 \x91\x90a lV[\x90Pa\x12b\x81_`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01\x7FUser has seTokens\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1B\xD1V[`\x1FT`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01Ra\x12\x9A\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90cp\xA0\x821\x90`$\x01a\x06\x1BV[`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12\xFDW__\xFD[PZ\xF1\x15\x80\x15a\x13\x0FW=__>=_\xFD[PP`@Q\x7F\xDB\0ju\0\0\0\0\0\0\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`\x01`\x01`\xA0\x1B\x03\x87\x16\x92Pc\xDB\0ju\x91P`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x13pW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13\x94\x91\x90a lV[P`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x85\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x13\xD8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13\xFC\x91\x90a lV[\x90Pa\x14>\x81_`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01\x7FUser has redeemed\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1CMV[`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01Ra\t\xEC\x90`\x01`\x01`\xA0\x1B\x03\x88\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x14\x85W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x14\xA9\x91\x90a lV[_`@Q\x80`@\x01`@R\x80`\x1B\x81R` \x01\x7FUser has SolvBTC.BBN tokens\0\0\0\0\0\x81RPa\x1B\xD1V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W\x83\x82\x90_R` _ \x01\x80Ta\x15%\x90a \x9EV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x15Q\x90a \x9EV[\x80\x15a\x15\x9CW\x80`\x1F\x10a\x15sWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x15\x9CV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15\x7FW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x15\x08V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x16\x8EW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x16;W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x15\xD3V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x17\x84W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x171W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x16\xC9V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W\x83\x82\x90_R` _ \x01\x80Ta\x17\xDC\x90a \x9EV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x18\x08\x90a \x9EV[\x80\x15a\x18SW\x80`\x1F\x10a\x18*Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x18SV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x186W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x17\xBFV[`\x08T_\x90`\xFF\x16\x15a\x18~WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x19\x0CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x190\x91\x90a lV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\n\x88W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\njWPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1A0W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x1AW\x91\x90\x81\x01\x90a!\x1CV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1Au\x92\x91\x90a!\xD0V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x1A\x91W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1A\xB5\x91\x90a lV[P`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1B!W__\xFD[PZ\xF1\x15\x80\x15a\x1B3W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x1B\xA6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1B\xCA\x91\x90a FV[PPPPPV[`@Q\x7F\xD9\xA3\xC4\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xD9\xA3\xC4\xD2\x90a\x1C%\x90\x86\x90\x86\x90\x86\x90`\x04\x01a!\xF1V[_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1C;W__\xFD[PZ\xFA\x15\x80\x15a\t\xECW=__>=_\xFD[`@Q\x7F\x88\xB4L\x85\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x88\xB4L\x85\x90a\x1C%\x90\x86\x90\x86\x90\x86\x90`\x04\x01a!\xF1V[a\x0C\xD4\x80a\"\x19\x839\x01\x90V[a\x0C\xC6\x80a.\xED\x839\x01\x90V[a\r\x8C\x80a;\xB3\x839\x01\x90V[a\x0F-\x80aI?\x839\x01\x90V[a\r \x80aXl\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1D\"W\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1C\xFBV[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1E6W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`\x01`\x01`\xA0\x1B\x03\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x1E\x1CW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x1E\x06\x84\x86Qa\x1D-V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x1D\xCCV[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x1D\x81V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x1E\x94W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x1ETV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1E6W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x1E\xEA`@\x88\x01\x82a\x1D-V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x1F\x05\x81\x83a\x1EBV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1E\xC4V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1E6W`?\x19\x87\x86\x03\x01\x84Ra\x1F^\x85\x83Qa\x1D-V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1FBV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1E6W`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1F\xD4`@\x87\x01\x82a\x1EBV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1F\x99V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x1F\xFEW__\xFD[PV[____`\x80\x85\x87\x03\x12\x15a \x14W__\xFD[\x845\x93P` \x85\x015a &\x81a\x1F\xEAV[\x92P`@\x85\x015a 6\x81a\x1F\xEAV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[_` \x82\x84\x03\x12\x15a VW__\xFD[\x81Q\x80\x15\x15\x81\x14a eW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a |W__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a \x93W__\xFD[\x81Qa e\x81a\x1F\xEAV[`\x01\x81\x81\x1C\x90\x82\x16\x80a \xB2W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a \xE9W\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[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!,W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a!BW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a!RW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a!lWa!la \xEFV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a!\x9CWa!\x9Ca \xEFV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a!\xB3W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a!\xE2`@\x83\x01\x85a\x1D-V[\x90P\x82` \x83\x01R\x93\x92PPPV[\x83\x81R\x82` \x82\x01R```@\x82\x01R_a\"\x0F``\x83\x01\x84a\x1D-V[\x95\x94PPPPPV\xFE`\xA0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x0C\xD48\x03\x80a\x0C\xD4\x839\x81\x01`@\x81\x90Ra\0.\x91a\0?V[`\x01`\x01`\xA0\x1B\x03\x16`\x80Ra\0lV[_` \x82\x84\x03\x12\x15a\0OW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0eW__\xFD[\x93\x92PPPV[`\x80Qa\x0C=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02UW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02y\x91\x90a\x0B,V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xE6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\n\x91\x90a\x0BGV[\x83Q\x90\x91P\x81\x10\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\x9Es\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x85\x83a\x05\xB4V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xB3\x90\x85\x90\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\x90`\x84\x01[`@\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\x0FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05-W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05Q\x91\x90a\x0BGV[a\x05[\x91\x90a\x0B^V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xB3\x90\x85\x90\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\x90`d\x01a\x04OV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x06\n\x90\x84\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\x90`d\x01a\x04OV[PPPV[_a\x06p\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\x07\x1A\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\nW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x8E\x91\x90a\x0B\x9CV[a\x06\nW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[``a\x07(\x84\x84_\x85a\x072V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xC4W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08BW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[__\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\x08j\x91\x90a\x0B\xBBV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xA4W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xA9V[``\x91P[P\x91P\x91Pa\x08\xB9\x82\x82\x86a\x08\xC4V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xD3WP\x81a\x07+V[\x82Q\x15a\x08\xE3W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03t\x91\x90a\x0B\xD1V[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\t8W__\xFD[PV[\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\x8BWa\t\x8Ba\t;V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xBAWa\t\xBAa\t;V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xD5W__\xFD[\x845a\t\xE0\x81a\t\x17V[\x93P` \x85\x015\x92P`@\x85\x015a\t\xF7\x81a\t\x17V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x12W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\"W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nz9,\xA4\xD4K\x0C\x1B\x8D=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xFA\x91\x90a\x0B\x1EV[`@Q\x7F#2>\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x88\x90R\x91\x92P_\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\x90c#2>\x03\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02\x91W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xB5\x91\x90a\x0B\x1EV[\x90P\x80\x15a\x03\nW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FCould not mint token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@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\x86\x81\x16`\x04\x83\x01R_\x91\x90\x85\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03wW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x9B\x91\x90a\x0B\x1EV[\x90P\x82\x81\x11a\x03\xECW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[_a\x03\xF7\x84\x83a\x0BbV[\x86Q\x90\x91P\x81\x10\x15a\x04KW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05c\x90\x85\x90\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\x90`\x84\x01[`@\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\x06dV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xDDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x01\x91\x90a\x0B\x1EV[a\x06\x0B\x91\x90a\x0B{V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05c\x90\x85\x90\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\x90`d\x01a\x04\xFFV[_a\x06\xC5\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\x07Z\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07UW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xE3\x91\x90a\x0B\x8EV[a\x07UW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[PPPV[``a\x07h\x84\x84_\x85a\x07rV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xEAW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08NW`@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\x03\x01V[__\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\x08v\x91\x90a\x0B\xADV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB0W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB5V[``\x91P[P\x91P\x91Pa\x08\xC5\x82\x82\x86a\x08\xD0V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xDFWP\x81a\x07kV[\x82Q\x15a\x08\xEFW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\x01\x91\x90a\x0B\xC3V[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\t*W__\xFD[PV[\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}Wa\t}a\t-V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xACWa\t\xACa\t-V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xC7W__\xFD[\x845a\t\xD2\x81a\t\tV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xE9\x81a\t\tV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x04W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x14W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n.Wa\n.a\t-V[a\nA` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x83V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nUW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x8AW__\xFD[\x855a\n\x95\x81a\t\tV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xAC\x81a\t\tV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xDDW__\xFD[Pa\n\xE6a\tZV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x0BW__\xFD[Pa\x0B\x14a\tZV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B.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`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x0BuWa\x0Bua\x0B5V[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0BuWa\x0Bua\x0B5V[_` \x82\x84\x03\x12\x15a\x0B\x9EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07kW__\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\xFE\xA2dipfsX\"\x12 \x96\xEFe\xB7\x9F\r\x80\x90U\x93\x15 \xD9\x88!\x13\xA9\xD5\xB6{=\xE4\xB8guk\xD84\x96\x11p%dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\x8C8\x03\x80a\r\x8C\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\xB6a\0\xD6_9_\x81\x81`\xCB\x01R\x81\x81a\x03\xE1\x01Ra\x04a\x01R_\x81\x81`S\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0C\xB6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c#\x17\x10\xA5\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xB0\xF1\xE3u\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\n=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFB\xFAw\xCF`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B\xA6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x0EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x032\x91\x90a\x0B\xA6V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xC3\x91\x90a\x0B\xC1V[\x90Pa\x04\x06s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x84V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xA2W__\xFD[PZ\xF1\x15\x80\x15a\x04\xB4W=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05~\x90\x85\x90\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\x90`\x84\x01[`@\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\x7FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1C\x91\x90a\x0B\xC1V[a\x06&\x91\x90a\x0B\xD8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05~\x90\x85\x90\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\x90`d\x01a\x05\x1AV[_a\x06\xE0\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\x07\x94\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\x8FW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFE\x91\x90a\x0C\x16V[a\x07\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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x07\xA2\x84\x84_\x85a\x07\xACV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08>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\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\x07\x86V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\xBCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x86V[__\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\x08\xE4\x91\x90a\x0C5V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\t\x1EW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t#V[``\x91P[P\x91P\x91Pa\t3\x82\x82\x86a\t>V[\x97\x96PPPPPPPV[``\x83\x15a\tMWP\x81a\x07\xA5V[\x82Q\x15a\t]W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x86\x91\x90a\x0CKV[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\t\xB2W__\xFD[PV[\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\n\x05Wa\n\x05a\t\xB5V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n4Wa\n4a\t\xB5V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\nOW__\xFD[\x845a\nZ\x81a\t\x91V[\x93P` \x85\x015\x92P`@\x85\x015a\nq\x81a\t\x91V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x8CW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x9CW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xB6Wa\n\xB6a\t\xB5V[a\n\xC9` `\x1F\x19`\x1F\x84\x01\x16\x01a\n\x0BV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n\xDDW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0B\x12W__\xFD[\x855a\x0B\x1D\x81a\t\x91V[\x94P` \x86\x015\x93P`@\x86\x015a\x0B4\x81a\t\x91V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0BeW__\xFD[Pa\x0Bna\t\xE2V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x93W__\xFD[Pa\x0B\x9Ca\t\xE2V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xB6W__\xFD[\x81Qa\x07\xA5\x81a\t\x91V[_` \x82\x84\x03\x12\x15a\x0B\xD1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0C\x10W\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[_` \x82\x84\x03\x12\x15a\x0C&W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\xA5W__\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\xFE\xA2dipfsX\"\x12 \xC8o\xCDB\x03\x85\xE3\xD8\xE52\x96F\x87\xCC\x1Eo\xE7\xC4i\x88\x13fC'6\x1Dq);\xA3\xF6ydsolcC\0\x08\x1C\x003a\x01@`@R4\x80\x15a\0\x10W__\xFD[P`@Qa\x0F-8\x03\x80a\x0F-\x839\x81\x01`@\x81\x90Ra\0/\x91a\0sV[`\x01`\x01`\xA0\x1B\x03\x95\x86\x16`\x80R\x93\x85\x16`\xA0R`\xC0\x92\x90\x92R`\xE0R\x82\x16a\x01\0R\x16a\x01 Ra\0\xE3V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0pW__\xFD[PV[______`\xC0\x87\x89\x03\x12\x15a\0\x88W__\xFD[\x86Qa\0\x93\x81a\0\\V[` \x88\x01Q\x90\x96Pa\0\xA4\x81a\0\\V[`@\x88\x01Q``\x89\x01Q`\x80\x8A\x01Q\x92\x97P\x90\x95P\x93Pa\0\xC4\x81a\0\\V[`\xA0\x88\x01Q\x90\x92Pa\0\xD5\x81a\0\\V[\x80\x91PP\x92\x95P\x92\x95P\x92\x95V[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\r\xC6a\x01g_9_\x81\x81a\x01.\x01R\x81\x81a\x04\xFC\x01Ra\x05>\x01R_\x81\x81a\x01U\x01Ra\x03R\x01R_\x81\x81a\x01\xB1\x01Ra\x03\xC1\x01R_\x81\x81a\x01|\x01Ra\x02\x88\x01R_\x81\x81`\xDF\x01R\x81\x81a\x03t\x01Ra\x03\xF0\x01R_\x81\x81`\x8E\x01R\x81\x81a\x02;\x01Ra\x02\xB7\x01Ra\r\xC6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\x85W_5`\xE0\x1C\x80c\xADt}\xE6\x11a\0XW\x80c\xADt}\xE6\x14a\x01)W\x80c\xB9\x93|\xCB\x14a\x01PW\x80c\xC8\xC7\xF7\x01\x14a\x01wW\x80c\xE3L\xEF\x86\x14a\x01\xACW__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0\x89W\x80cN=\xF3\xF4\x14a\0\xDAW\x80cPcL\x0E\x14a\x01\x01W\x80c\x7F\x81O5\x14a\x01\x16W[__\xFD[a\0\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\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\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\x81V[a\x01\x14a\x01\x0F6`\x04a\x0BgV[a\x01\xD3V[\0[a\x01\x14a\x01$6`\x04a\x0C)V[a\x01\xFDV[a\0\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\x81V[a\0\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\x81V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xD1V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\xE8\x91\x90a\x0C\xADV[\x90Pa\x01\xF6\x85\x85\x85\x84a\x01\xFDV[PPPPPV[a\x02\x1Fs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x9AV[a\x02`s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x036\x91\x90a\x0C\xD1V[\x90Pa\x03\x99s\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\x7F\0\0\0\0\0\0\0\0\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\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x82\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04KW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04o\x91\x90a\x0C\xD1V[\x83Q\x90\x91P\x81\x10\x15a\x04\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[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\x85\x83a\x07YV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x06X\x90\x85\x90\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\x90`\x84\x01[`@\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\x07\xB4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF6\x91\x90a\x0C\xD1V[a\x07\0\x91\x90a\x0C\xE8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x06X\x90\x85\x90\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\x90`d\x01a\x05\xF4V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07\xAF\x90\x84\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\x90`d\x01a\x05\xF4V[PPPV[_a\x08\x15\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\x08\xBF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\xAFW\x80\x80` \x01\x90Q\x81\x01\x90a\x083\x91\x90a\r&V[a\x07\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\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\x04\xD9V[``a\x08\xCD\x84\x84_\x85a\x08\xD7V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\tiW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x04\xD9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\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`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x04\xD9V[__\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\n\x0F\x91\x90a\rEV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\nIW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\nNV[``\x91P[P\x91P\x91Pa\n^\x82\x82\x86a\niV[\x97\x96PPPPPPPV[``\x83\x15a\nxWP\x81a\x08\xD0V[\x82Q\x15a\n\x88W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x04\xD9\x91\x90a\r[V[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\xDDW__\xFD[PV[\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\x0B0Wa\x0B0a\n\xE0V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0B_Wa\x0B_a\n\xE0V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0BzW__\xFD[\x845a\x0B\x85\x81a\n\xBCV[\x93P` \x85\x015\x92P`@\x85\x015a\x0B\x9C\x81a\n\xBCV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xB7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\x0B\xC7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xE1Wa\x0B\xE1a\n\xE0V[a\x0B\xF4` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0B6V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0C\x08W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0C=W__\xFD[\x855a\x0CH\x81a\n\xBCV[\x94P` \x86\x015\x93P`@\x86\x015a\x0C_\x81a\n\xBCV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0C\x90W__\xFD[Pa\x0C\x99a\x0B\rV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0C\xBEW__\xFD[Pa\x0C\xC7a\x0B\rV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C\xE1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\r 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[_` \x82\x84\x03\x12\x15a\r6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x08\xD0W__\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\xFE\xA2dipfsX\"\x12 \xD28\x8C\xB3\xDCz\xA6\xF5\xA2\xEBuA}\x11\x05\x9B\xE1<\x8C\x9E\xAB\xE5\xD7\xEA\xDB\x1BV\x1F\x93\x7F\xF6\x91dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r 8\x03\x80a\r \x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CJa\0\xD6_9_\x81\x81`{\x01R\x81\x81a\x03u\x01Ra\x03\xF5\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0CJ_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cPcL\x0E\x14a\0NW\x80c\x7F\x81O5\x14a\0cW\x80c\xB0\xF1\xE3u\x14a\0vW\x80c\xF2#L\xF9\x14a\0\xC6W[__\xFD[a\0aa\0\\6`\x04a\t\xD0V[a\0\xEDV[\0[a\0aa\0q6`\x04a\n\x92V[a\x01\x17V[a\0\x9D\x7F\0\0\0\0\0\0\0\0\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\x9D\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 \"\x8F\x03\x84\x07\x19t\xAAf\xF7u\xC6\x06\xB7\xDD\x8B\x8AKq\xA1\x9E<9!\xA2\xDD\xC4}\xE1\xC4\xDAcdsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 Ro.\xA5\xB6\x05\xF8m\x98\x0B\x9Cn\x962\xA2\xC4h\x14\xCB\xAF\x88\xEB\x14})\xE6\xFEc \x1E\xA5\xF9dsolcC\0\x08\x1C\x003", ); #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] @@ -4102,64 +3978,6 @@ event logs(bytes); } } }; - /**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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolConstructor for constructorCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - } - }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. @@ -5082,31 +4900,17 @@ function failed() external view returns (bool); }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getBlockHeights(string,uint256,uint256)` and selector `0xfad06b8f`. + /**Function with signature `setUp()` and selector `0x0a9254e4`. ```solidity -function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); +function setUp() external; ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getBlockHeightsCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getBlockHeights(string,uint256,uint256)`](getBlockHeightsCall) function. + pub struct setUpCall; + ///Container type for the return parameters of the [`setUp()`](setUpCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getBlockHeightsReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >, - } + pub struct setUpReturn {} #[allow( non_camel_case_types, non_snake_case, @@ -5117,17 +4921,9 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte use alloy::sol_types as alloy_sol_types; { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - 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::String, - 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( @@ -5141,34 +4937,24 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsCall) -> Self { - (value.chainName, value.from, value.to) + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpCall) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getBlockHeightsCall { + impl ::core::convert::From> for setUpCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } + Self } } } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); + type UnderlyingSolTuple<'a> = (); #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >, - ); + type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -5182,42 +4968,39 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsReturn) -> Self { - (value.elements,) + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpReturn) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> - for getBlockHeightsReturn { + impl ::core::convert::From> for setUpReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } + Self {} } } } + impl setUpReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } #[automatically_derived] - impl alloy_sol_types::SolCall for getBlockHeightsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); + impl alloy_sol_types::SolCall for setUpCall { + type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); + type Return = setUpReturn; + type ReturnTuple<'a> = (); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getBlockHeights(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [250u8, 208u8, 107u8, 143u8]; + const SIGNATURE: &'static str = "setUp()"; + const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -5226,35 +5009,18 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte } #[inline] fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) + () } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) + setUpReturn::_tokenize(ret) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) + .map(Into::into) } #[inline] fn abi_decode_returns_validate( @@ -5263,40 +5029,32 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) + .map(Into::into) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getDigestLes(string,uint256,uint256)` and selector `0x44badbb6`. + /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. ```solidity -function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); +function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getDigestLesCall { + pub struct simulateForkAndTransferCall { + #[allow(missing_docs)] + pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, + pub sender: alloy::sol_types::private::Address, #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, + pub receiver: alloy::sol_types::private::Address, #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, + pub amount: alloy::sol_types::private::primitives::aliases::U256, } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getDigestLes(string,uint256,uint256)`](getDigestLesCall) function. + ///Container type for the return parameters of the [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getDigestLesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >, - } + pub struct simulateForkAndTransferReturn {} #[allow( non_camel_case_types, non_snake_case, @@ -5308,14 +5066,16 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa { #[doc(hidden)] 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::Uint<256>, ); #[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::primitives::aliases::U256, ); #[cfg(test)] @@ -5331,36 +5091,31 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesCall) -> Self { - (value.chainName, value.from, value.to) + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferCall) -> Self { + (value.forkAtBlock, value.sender, value.receiver, value.amount) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getDigestLesCall { + impl ::core::convert::From> + for simulateForkAndTransferCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, + forkAtBlock: tuple.0, + sender: tuple.1, + receiver: tuple.2, + amount: tuple.3, } } } } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array< - alloy::sol_types::sol_data::FixedBytes<32>, - >, - ); + type UnderlyingSolTuple<'a> = (); #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >, - ); + type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -5374,42 +5129,48 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesReturn) -> Self { - (value.elements,) + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferReturn) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getDigestLesReturn { + impl ::core::convert::From> + for simulateForkAndTransferReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } + Self {} } } } + impl simulateForkAndTransferReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } #[automatically_derived] - impl alloy_sol_types::SolCall for getDigestLesCall { + impl alloy_sol_types::SolCall for simulateForkAndTransferCall { type Parameters<'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::Uint<256>, ); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array< - alloy::sol_types::sol_data::FixedBytes<32>, - >, - ); + type Return = simulateForkAndTransferReturn; + type ReturnTuple<'a> = (); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getDigestLes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [68u8, 186u8, 219u8, 182u8]; + const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; + const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -5419,34 +5180,30 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - ::tokenize( - &self.chainName, - ), as alloy_sol_types::SolType>::tokenize(&self.from), + > as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), + ::tokenize( + &self.sender, + ), + ::tokenize( + &self.receiver, + ), as alloy_sol_types::SolType>::tokenize(&self.to), + > as alloy_sol_types::SolType>::tokenize(&self.amount), ) } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) + simulateForkAndTransferReturn::_tokenize(ret) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) + .map(Into::into) } #[inline] fn abi_decode_returns_validate( @@ -5455,37 +5212,29 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements - }) + .map(Into::into) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaderHexes(string,uint256,uint256)` and selector `0x0813852a`. + /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. ```solidity -function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); +function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getHeaderHexesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } + pub struct targetArtifactSelectorsCall; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaderHexes(string,uint256,uint256)`](getHeaderHexesCall) function. + ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getHeaderHexesReturn { + pub struct targetArtifactSelectorsReturn { #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec, + pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, } #[allow( non_camel_case_types, @@ -5497,17 +5246,9 @@ function getHeaderHexes(string memory chainName, uint256 from, uint256 to) exter use alloy::sol_types as alloy_sol_types; { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - 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::String, - 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( @@ -5521,31 +5262,31 @@ function getHeaderHexes(string memory chainName, uint256 from, uint256 to) exter } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesCall) -> Self { - (value.chainName, value.from, value.to) + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactSelectorsCall) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getHeaderHexesCall { + impl ::core::convert::From> + for targetArtifactSelectorsCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } + Self } } } { #[doc(hidden)] type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array, ); #[doc(hidden)] type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, + alloy::sol_types::private::Vec< + ::RustType, + >, ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] @@ -5560,42 +5301,40 @@ function getHeaderHexes(string memory chainName, uint256 from, uint256 to) exter } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesReturn) -> Self { - (value.elements,) + fn from(value: targetArtifactSelectorsReturn) -> Self { + (value.targetedArtifactSelectors_,) } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for getHeaderHexesReturn { + for targetArtifactSelectorsReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } + Self { + targetedArtifactSelectors_: tuple.0, + } } } } #[automatically_derived] - impl alloy_sol_types::SolCall for getHeaderHexesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); + impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { + type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Bytes, + ::RustType, >; type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array, ); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaderHexes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [8u8, 19u8, 133u8, 42u8]; + const SIGNATURE: &'static str = "targetArtifactSelectors()"; + const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -5604,23 +5343,13 @@ function getHeaderHexes(string memory chainName, uint256 from, uint256 to) exter } #[inline] fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) + () } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { ( as alloy_sol_types::SolType>::tokenize(ret), ) } @@ -5630,8 +5359,8 @@ function getHeaderHexes(string memory chainName, uint256 from, uint256 to) exter '_, > as alloy_sol_types::SolType>::abi_decode_sequence(data) .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ }) } #[inline] @@ -5642,36 +5371,31 @@ function getHeaderHexes(string memory chainName, uint256 from, uint256 to) exter '_, > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ }) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaders(string,uint256,uint256)` and selector `0x1c0da81f`. + /**Function with signature `targetArtifacts()` and selector `0x85226c81`. ```solidity -function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); +function targetArtifacts() external view returns (string[] memory targetedArtifacts_); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getHeadersCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } + pub struct targetArtifactsCall; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaders(string,uint256,uint256)`](getHeadersCall) function. + ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getHeadersReturn { + pub struct targetArtifactsReturn { #[allow(missing_docs)] - pub headers: alloy::sol_types::private::Bytes, + pub targetedArtifacts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >, } #[allow( non_camel_case_types, @@ -5683,17 +5407,9 @@ function getHeaders(string memory chainName, uint256 from, uint256 to) external use alloy::sol_types as alloy_sol_types; { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - 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::String, - 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( @@ -5707,28 +5423,28 @@ function getHeaders(string memory chainName, uint256 from, uint256 to) external } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersCall) -> Self { - (value.chainName, value.from, value.to) + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsCall) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getHeadersCall { + impl ::core::convert::From> for targetArtifactsCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } + Self } } } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Bytes,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -5742,36 +5458,40 @@ function getHeaders(string memory chainName, uint256 from, uint256 to) external } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersReturn) -> Self { - (value.headers,) + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsReturn) -> Self { + (value.targetedArtifacts_,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getHeadersReturn { + impl ::core::convert::From> + for targetArtifactsReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { headers: tuple.0 } + Self { + targetedArtifacts_: tuple.0, + } } } } #[automatically_derived] - impl alloy_sol_types::SolCall for getHeadersCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); + impl alloy_sol_types::SolCall for targetArtifactsCall { + type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Bytes; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaders(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [28u8, 13u8, 168u8, 31u8]; + const SIGNATURE: &'static str = "targetArtifacts()"; + const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -5780,24 +5500,14 @@ function getHeaders(string memory chainName, uint256 from, uint256 to) external } #[inline] fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) + () } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { ( - ::tokenize( - ret, - ), + as alloy_sol_types::SolType>::tokenize(ret), ) } #[inline] @@ -5806,8 +5516,8 @@ function getHeaders(string memory chainName, uint256 from, uint256 to) external '_, > as alloy_sol_types::SolType>::abi_decode_sequence(data) .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ }) } #[inline] @@ -5818,30 +5528,30 @@ function getHeaders(string memory chainName, uint256 from, uint256 to) external '_, > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ }) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. + /**Function with signature `targetContracts()` and selector `0x3f7286f4`. ```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); +function targetContracts() external view returns (address[] memory targetedContracts_); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetArtifactSelectorsCall; + pub struct targetContractsCall; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. + ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { + pub struct targetContractsReturn { #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, + pub targetedContracts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, >, } #[allow( @@ -5870,16 +5580,14 @@ function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtif } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetContractsCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { + impl ::core::convert::From> for targetContractsCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -5888,1090 +5596,12 @@ function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtif { #[doc(hidden)] type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array, ); #[doc(hidden)] type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testDescendantLeftBelowAncestor()` and selector `0x61ac8013`. -```solidity -function testDescendantLeftBelowAncestor() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testDescendantLeftBelowAncestorCall; - ///Container type for the return parameters of the [`testDescendantLeftBelowAncestor()`](testDescendantLeftBelowAncestorCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testDescendantLeftBelowAncestorReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testDescendantLeftBelowAncestorCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testDescendantLeftBelowAncestorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testDescendantLeftBelowAncestorReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testDescendantLeftBelowAncestorReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testDescendantLeftBelowAncestorReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testDescendantLeftBelowAncestorCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testDescendantLeftBelowAncestorReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testDescendantLeftBelowAncestor()"; - const SELECTOR: [u8; 4] = [97u8, 172u8, 128u8, 19u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testDescendantLeftBelowAncestorReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testDescendantRightBelowAncestor()` and selector `0x18aae36c`. -```solidity -function testDescendantRightBelowAncestor() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testDescendantRightBelowAncestorCall; - ///Container type for the return parameters of the [`testDescendantRightBelowAncestor()`](testDescendantRightBelowAncestorCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testDescendantRightBelowAncestorReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testDescendantRightBelowAncestorCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testDescendantRightBelowAncestorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); + alloy::sol_types::private::Vec, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -6985,43 +5615,40 @@ function testDescendantRightBelowAncestor() external; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: testDescendantRightBelowAncestorReturn) -> Self { - () + fn from(value: targetContractsReturn) -> Self { + (value.targetedContracts_,) } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for testDescendantRightBelowAncestorReturn { + for targetContractsReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} + Self { + targetedContracts_: tuple.0, + } } } } - impl testDescendantRightBelowAncestorReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } #[automatically_derived] - impl alloy_sol_types::SolCall for testDescendantRightBelowAncestorCall { + impl alloy_sol_types::SolCall for targetContractsCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testDescendantRightBelowAncestorReturn; - type ReturnTuple<'a> = (); + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testDescendantRightBelowAncestor()"; - const SELECTOR: [u8; 4] = [24u8, 170u8, 227u8, 108u8]; + const SIGNATURE: &'static str = "targetContracts()"; + const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -7034,14 +5661,21 @@ function testDescendantRightBelowAncestor() external; } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testDescendantRightBelowAncestorReturn::_tokenize(ret) + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) + .map(|r| { + let r: targetContractsReturn = r.into(); + r.targetedContracts_ + }) } #[inline] fn abi_decode_returns_validate( @@ -7050,23 +5684,33 @@ function testDescendantRightBelowAncestor() external; as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) + .map(|r| { + let r: targetContractsReturn = r.into(); + r.targetedContracts_ + }) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testEqualWeightsReturnsLeft()` and selector `0xdb84fc88`. + /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. ```solidity -function testEqualWeightsReturnsLeft() external view; +function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testEqualWeightsReturnsLeftCall; - ///Container type for the return parameters of the [`testEqualWeightsReturnsLeft()`](testEqualWeightsReturnsLeftCall) function. + pub struct targetInterfacesCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testEqualWeightsReturnsLeftReturn {} + pub struct targetInterfacesReturn { + #[allow(missing_docs)] + pub targetedInterfaces_: alloy::sol_types::private::Vec< + ::RustType, + >, + } #[allow( non_camel_case_types, non_snake_case, @@ -7093,16 +5737,16 @@ function testEqualWeightsReturnsLeft() external view; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: testEqualWeightsReturnsLeftCall) -> Self { + fn from(value: targetInterfacesCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for testEqualWeightsReturnsLeftCall { + for targetInterfacesCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -7110,9 +5754,15 @@ function testEqualWeightsReturnsLeft() external view; } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -7126,43 +5776,40 @@ function testEqualWeightsReturnsLeft() external view; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: testEqualWeightsReturnsLeftReturn) -> Self { - () + fn from(value: targetInterfacesReturn) -> Self { + (value.targetedInterfaces_,) } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for testEqualWeightsReturnsLeftReturn { + for targetInterfacesReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} + Self { + targetedInterfaces_: tuple.0, + } } } } - impl testEqualWeightsReturnsLeftReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } #[automatically_derived] - impl alloy_sol_types::SolCall for testEqualWeightsReturnsLeftCall { + impl alloy_sol_types::SolCall for targetInterfacesCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testEqualWeightsReturnsLeftReturn; - type ReturnTuple<'a> = (); + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testEqualWeightsReturnsLeft()"; - const SELECTOR: [u8; 4] = [219u8, 132u8, 252u8, 136u8]; + const SIGNATURE: &'static str = "targetInterfaces()"; + const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -7175,14 +5822,21 @@ function testEqualWeightsReturnsLeft() external view; } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testEqualWeightsReturnsLeftReturn::_tokenize(ret) + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) + .map(|r| { + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ + }) } #[inline] fn abi_decode_returns_validate( @@ -7191,23 +5845,33 @@ function testEqualWeightsReturnsLeft() external view; as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) + .map(|r| { + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ + }) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testLeftIsHeavier()` and selector `0xd2addbb8`. + /**Function with signature `targetSelectors()` and selector `0x916a17c6`. ```solidity -function testLeftIsHeavier() external view; +function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testLeftIsHeavierCall; - ///Container type for the return parameters of the [`testLeftIsHeavier()`](testLeftIsHeavierCall) function. + pub struct targetSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testLeftIsHeavierReturn {} + pub struct targetSelectorsReturn { + #[allow(missing_docs)] + pub targetedSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } #[allow( non_camel_case_types, non_snake_case, @@ -7234,16 +5898,14 @@ function testLeftIsHeavier() external view; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testLeftIsHeavierCall) -> Self { + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSelectorsCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> - for testLeftIsHeavierCall { + impl ::core::convert::From> for targetSelectorsCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -7251,9 +5913,15 @@ function testLeftIsHeavier() external view; } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -7267,41 +5935,40 @@ function testLeftIsHeavier() external view; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: testLeftIsHeavierReturn) -> Self { - () + fn from(value: targetSelectorsReturn) -> Self { + (value.targetedSelectors_,) } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for testLeftIsHeavierReturn { + for targetSelectorsReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} + Self { + targetedSelectors_: tuple.0, + } } } } - impl testLeftIsHeavierReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } #[automatically_derived] - impl alloy_sol_types::SolCall for testLeftIsHeavierCall { + impl alloy_sol_types::SolCall for targetSelectorsCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testLeftIsHeavierReturn; - type ReturnTuple<'a> = (); + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testLeftIsHeavier()"; - const SELECTOR: [u8; 4] = [210u8, 173u8, 219u8, 184u8]; + const SIGNATURE: &'static str = "targetSelectors()"; + const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -7314,14 +5981,21 @@ function testLeftIsHeavier() external view; } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testLeftIsHeavierReturn::_tokenize(ret) + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) + .map(|r| { + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ + }) } #[inline] fn abi_decode_returns_validate( @@ -7330,23 +6004,33 @@ function testLeftIsHeavier() external view; as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) + .map(|r| { + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ + }) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testRightIsHeavier()` and selector `0x96a78d77`. + /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. ```solidity -function testRightIsHeavier() external view; +function targetSenders() external view returns (address[] memory targetedSenders_); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testRightIsHeavierCall; - ///Container type for the return parameters of the [`testRightIsHeavier()`](testRightIsHeavierCall) function. + pub struct targetSendersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testRightIsHeavierReturn {} + pub struct targetSendersReturn { + #[allow(missing_docs)] + pub targetedSenders_: alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >, + } #[allow( non_camel_case_types, non_snake_case, @@ -7373,16 +6057,14 @@ function testRightIsHeavier() external view; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testRightIsHeavierCall) -> Self { + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> - for testRightIsHeavierCall { + impl ::core::convert::From> for targetSendersCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -7390,9 +6072,13 @@ function testRightIsHeavier() external view; } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -7406,41 +6092,36 @@ function testRightIsHeavier() external view; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testRightIsHeavierReturn) -> Self { - () + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersReturn) -> Self { + (value.targetedSenders_,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> - for testRightIsHeavierReturn { + impl ::core::convert::From> for targetSendersReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} + Self { targetedSenders_: tuple.0 } } } } - impl testRightIsHeavierReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } #[automatically_derived] - impl alloy_sol_types::SolCall for testRightIsHeavierCall { + impl alloy_sol_types::SolCall for targetSendersCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testRightIsHeavierReturn; - type ReturnTuple<'a> = (); + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testRightIsHeavier()"; - const SELECTOR: [u8; 4] = [150u8, 167u8, 141u8, 119u8]; + const SIGNATURE: &'static str = "targetSenders()"; + const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -7453,14 +6134,21 @@ function testRightIsHeavier() external view; } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testRightIsHeavierReturn::_tokenize(ret) + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) + .map(|r| { + let r: targetSendersReturn = r.into(); + r.targetedSenders_ + }) } #[inline] fn abi_decode_returns_validate( @@ -7469,23 +6157,26 @@ function testRightIsHeavier() external view; as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) + .map(|r| { + let r: targetSendersReturn = r.into(); + r.targetedSenders_ + }) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testUnknownAncestor()` and selector `0xf3ac250c`. + /**Function with signature `testSegmentBedrockStrategy()` and selector `0x003f2b1d`. ```solidity -function testUnknownAncestor() external; +function testSegmentBedrockStrategy() external; ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testUnknownAncestorCall; - ///Container type for the return parameters of the [`testUnknownAncestor()`](testUnknownAncestorCall) function. + pub struct testSegmentBedrockStrategyCall; + ///Container type for the return parameters of the [`testSegmentBedrockStrategy()`](testSegmentBedrockStrategyCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testUnknownAncestorReturn {} + pub struct testSegmentBedrockStrategyReturn {} #[allow( non_camel_case_types, non_snake_case, @@ -7512,16 +6203,16 @@ function testUnknownAncestor() external; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: testUnknownAncestorCall) -> Self { + fn from(value: testSegmentBedrockStrategyCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for testUnknownAncestorCall { + for testSegmentBedrockStrategyCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -7545,41 +6236,43 @@ function testUnknownAncestor() external; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: testUnknownAncestorReturn) -> Self { + fn from(value: testSegmentBedrockStrategyReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for testUnknownAncestorReturn { + for testSegmentBedrockStrategyReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } } } - impl testUnknownAncestorReturn { + impl testSegmentBedrockStrategyReturn { fn _tokenize( &self, - ) -> ::ReturnToken<'_> { + ) -> ::ReturnToken< + '_, + > { () } } #[automatically_derived] - impl alloy_sol_types::SolCall for testUnknownAncestorCall { + impl alloy_sol_types::SolCall for testSegmentBedrockStrategyCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testUnknownAncestorReturn; + type Return = testSegmentBedrockStrategyReturn; type ReturnTuple<'a> = (); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testUnknownAncestor()"; - const SELECTOR: [u8; 4] = [243u8, 172u8, 37u8, 12u8]; + const SIGNATURE: &'static str = "testSegmentBedrockStrategy()"; + const SELECTOR: [u8; 4] = [0u8, 63u8, 43u8, 29u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -7592,7 +6285,7 @@ function testUnknownAncestor() external; } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testUnknownAncestorReturn::_tokenize(ret) + testSegmentBedrockStrategyReturn::_tokenize(ret) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { @@ -7614,17 +6307,17 @@ function testUnknownAncestor() external; }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testUnknownLeft()` and selector `0x97ec36e9`. + /**Function with signature `testSegmentSolvLstStrategy()` and selector `0x6b396413`. ```solidity -function testUnknownLeft() external; +function testSegmentSolvLstStrategy() external; ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testUnknownLeftCall; - ///Container type for the return parameters of the [`testUnknownLeft()`](testUnknownLeftCall) function. + pub struct testSegmentSolvLstStrategyCall; + ///Container type for the return parameters of the [`testSegmentSolvLstStrategy()`](testSegmentSolvLstStrategyCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testUnknownLeftReturn {} + pub struct testSegmentSolvLstStrategyReturn {} #[allow( non_camel_case_types, non_snake_case, @@ -7651,14 +6344,16 @@ function testUnknownLeft() external; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: testUnknownLeftCall) -> Self { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: testSegmentSolvLstStrategyCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for testUnknownLeftCall { + impl ::core::convert::From> + for testSegmentSolvLstStrategyCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -7682,41 +6377,43 @@ function testUnknownLeft() external; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: testUnknownLeftReturn) -> Self { + fn from(value: testSegmentSolvLstStrategyReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for testUnknownLeftReturn { + for testSegmentSolvLstStrategyReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } } } - impl testUnknownLeftReturn { + impl testSegmentSolvLstStrategyReturn { fn _tokenize( &self, - ) -> ::ReturnToken<'_> { + ) -> ::ReturnToken< + '_, + > { () } } #[automatically_derived] - impl alloy_sol_types::SolCall for testUnknownLeftCall { + impl alloy_sol_types::SolCall for testSegmentSolvLstStrategyCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testUnknownLeftReturn; + type Return = testSegmentSolvLstStrategyReturn; type ReturnTuple<'a> = (); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testUnknownLeft()"; - const SELECTOR: [u8; 4] = [151u8, 236u8, 54u8, 233u8]; + const SIGNATURE: &'static str = "testSegmentSolvLstStrategy()"; + const SELECTOR: [u8; 4] = [107u8, 57u8, 100u8, 19u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -7729,7 +6426,7 @@ function testUnknownLeft() external; } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testUnknownLeftReturn::_tokenize(ret) + testSegmentSolvLstStrategyReturn::_tokenize(ret) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { @@ -7751,17 +6448,22 @@ function testUnknownLeft() external; }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testUnknownRight()` and selector `0x827d7db1`. + /**Function with signature `token()` and selector `0xfc0c546a`. ```solidity -function testUnknownRight() external; +function token() external view returns (address); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testUnknownRightCall; - ///Container type for the return parameters of the [`testUnknownRight()`](testUnknownRightCall) function. + pub struct tokenCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`token()`](tokenCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct testUnknownRightReturn {} + pub struct tokenReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Address, + } #[allow( non_camel_case_types, non_snake_case, @@ -7788,16 +6490,14 @@ function testUnknownRight() external; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testUnknownRightCall) -> Self { + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> - for testUnknownRightCall { + impl ::core::convert::From> for tokenCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -7805,9 +6505,9 @@ function testUnknownRight() external; } { #[doc(hidden)] - 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( @@ -7821,41 +6521,32 @@ function testUnknownRight() external; } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testUnknownRightReturn) -> Self { - () + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenReturn) -> Self { + (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> - for testUnknownRightReturn { + impl ::core::convert::From> for tokenReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} + Self { _0: tuple.0 } } } } - impl testUnknownRightReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } #[automatically_derived] - impl alloy_sol_types::SolCall for testUnknownRightCall { + impl alloy_sol_types::SolCall for tokenCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testUnknownRightReturn; - type ReturnTuple<'a> = (); + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testUnknownRight()"; - const SELECTOR: [u8; 4] = [130u8, 125u8, 125u8, 177u8]; + const SIGNATURE: &'static str = "token()"; + const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -7868,14 +6559,21 @@ function testUnknownRight() external; } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testUnknownRightReturn::_tokenize(ret) + ( + ::tokenize( + ret, + ), + ) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) } #[inline] fn abi_decode_returns_validate( @@ -7884,14 +6582,17 @@ function testUnknownRight() external; as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) } } }; - ///Container for all the [`FullRelayHeaviestFromAncestorTest`](self) function calls. + ///Container for all the [`SegmentBedrockAndLstStrategyForked`](self) function calls. #[derive(serde::Serialize, serde::Deserialize)] #[derive()] - pub enum FullRelayHeaviestFromAncestorTestCalls { + pub enum SegmentBedrockAndLstStrategyForkedCalls { #[allow(missing_docs)] IS_TEST(IS_TESTCall), #[allow(missing_docs)] @@ -7905,13 +6606,9 @@ function testUnknownRight() external; #[allow(missing_docs)] failed(failedCall), #[allow(missing_docs)] - getBlockHeights(getBlockHeightsCall), - #[allow(missing_docs)] - getDigestLes(getDigestLesCall), + setUp(setUpCall), #[allow(missing_docs)] - getHeaderHexes(getHeaderHexesCall), - #[allow(missing_docs)] - getHeaders(getHeadersCall), + simulateForkAndTransfer(simulateForkAndTransferCall), #[allow(missing_docs)] targetArtifactSelectors(targetArtifactSelectorsCall), #[allow(missing_docs)] @@ -7925,24 +6622,14 @@ function testUnknownRight() external; #[allow(missing_docs)] targetSenders(targetSendersCall), #[allow(missing_docs)] - testDescendantLeftBelowAncestor(testDescendantLeftBelowAncestorCall), - #[allow(missing_docs)] - testDescendantRightBelowAncestor(testDescendantRightBelowAncestorCall), - #[allow(missing_docs)] - testEqualWeightsReturnsLeft(testEqualWeightsReturnsLeftCall), - #[allow(missing_docs)] - testLeftIsHeavier(testLeftIsHeavierCall), + testSegmentBedrockStrategy(testSegmentBedrockStrategyCall), #[allow(missing_docs)] - testRightIsHeavier(testRightIsHeavierCall), + testSegmentSolvLstStrategy(testSegmentSolvLstStrategyCall), #[allow(missing_docs)] - testUnknownAncestor(testUnknownAncestorCall), - #[allow(missing_docs)] - testUnknownLeft(testUnknownLeftCall), - #[allow(missing_docs)] - testUnknownRight(testUnknownRightCall), + token(tokenCall), } #[automatically_derived] - impl FullRelayHeaviestFromAncestorTestCalls { + impl SegmentBedrockAndLstStrategyForkedCalls { /// All the selectors of this enum. /// /// Note that the selectors might not be in the same order as the variants. @@ -7950,37 +6637,30 @@ function testUnknownRight() external; /// /// Prefer using `SolInterface` methods instead. pub const SELECTORS: &'static [[u8; 4usize]] = &[ - [8u8, 19u8, 133u8, 42u8], - [24u8, 170u8, 227u8, 108u8], - [28u8, 13u8, 168u8, 31u8], + [0u8, 63u8, 43u8, 29u8], + [10u8, 146u8, 84u8, 228u8], [30u8, 215u8, 131u8, 28u8], [42u8, 222u8, 56u8, 128u8], [62u8, 94u8, 60u8, 35u8], [63u8, 114u8, 134u8, 244u8], - [68u8, 186u8, 219u8, 182u8], - [97u8, 172u8, 128u8, 19u8], [102u8, 217u8, 169u8, 160u8], - [130u8, 125u8, 125u8, 177u8], + [107u8, 57u8, 100u8, 19u8], [133u8, 34u8, 108u8, 129u8], [145u8, 106u8, 23u8, 198u8], - [150u8, 167u8, 141u8, 119u8], - [151u8, 236u8, 54u8, 233u8], [176u8, 70u8, 79u8, 220u8], [181u8, 80u8, 138u8, 169u8], [186u8, 65u8, 79u8, 166u8], - [210u8, 173u8, 219u8, 184u8], - [219u8, 132u8, 252u8, 136u8], [226u8, 12u8, 159u8, 113u8], - [243u8, 172u8, 37u8, 12u8], + [249u8, 206u8, 14u8, 90u8], [250u8, 118u8, 38u8, 212u8], - [250u8, 208u8, 107u8, 143u8], + [252u8, 12u8, 84u8, 106u8], ]; } #[automatically_derived] - impl alloy_sol_types::SolInterface for FullRelayHeaviestFromAncestorTestCalls { - const NAME: &'static str = "FullRelayHeaviestFromAncestorTestCalls"; + impl alloy_sol_types::SolInterface for SegmentBedrockAndLstStrategyForkedCalls { + const NAME: &'static str = "SegmentBedrockAndLstStrategyForkedCalls"; const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 24usize; + const COUNT: usize = 17usize; #[inline] fn selector(&self) -> [u8; 4] { match self { @@ -7998,17 +6678,9 @@ function testUnknownRight() external; ::SELECTOR } Self::failed(_) => ::SELECTOR, - Self::getBlockHeights(_) => { - ::SELECTOR - } - Self::getDigestLes(_) => { - ::SELECTOR - } - Self::getHeaderHexes(_) => { - ::SELECTOR - } - Self::getHeaders(_) => { - ::SELECTOR + Self::setUp(_) => ::SELECTOR, + Self::simulateForkAndTransfer(_) => { + ::SELECTOR } Self::targetArtifactSelectors(_) => { ::SELECTOR @@ -8028,30 +6700,13 @@ function testUnknownRight() external; Self::targetSenders(_) => { ::SELECTOR } - Self::testDescendantLeftBelowAncestor(_) => { - ::SELECTOR - } - Self::testDescendantRightBelowAncestor(_) => { - ::SELECTOR - } - Self::testEqualWeightsReturnsLeft(_) => { - ::SELECTOR - } - Self::testLeftIsHeavier(_) => { - ::SELECTOR + Self::testSegmentBedrockStrategy(_) => { + ::SELECTOR } - Self::testRightIsHeavier(_) => { - ::SELECTOR - } - Self::testUnknownAncestor(_) => { - ::SELECTOR - } - Self::testUnknownLeft(_) => { - ::SELECTOR - } - Self::testUnknownRight(_) => { - ::SELECTOR + Self::testSegmentSolvLstStrategy(_) => { + ::SELECTOR } + Self::token(_) => ::SELECTOR, } } #[inline] @@ -8070,58 +6725,43 @@ function testUnknownRight() external; ) -> alloy_sol_types::Result { static DECODE_SHIMS: &[fn( &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map(FullRelayHeaviestFromAncestorTestCalls::getHeaderHexes) - } - getHeaderHexes - }, + ) -> alloy_sol_types::Result] = &[ { - fn testDescendantRightBelowAncestor( + fn testSegmentBedrockStrategy( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { - ::abi_decode_raw( + ::abi_decode_raw( data, ) .map( - FullRelayHeaviestFromAncestorTestCalls::testDescendantRightBelowAncestor, + SegmentBedrockAndLstStrategyForkedCalls::testSegmentBedrockStrategy, ) } - testDescendantRightBelowAncestor + testSegmentBedrockStrategy }, { - fn getHeaders( + fn setUp( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { - ::abi_decode_raw( - data, - ) - .map(FullRelayHeaviestFromAncestorTestCalls::getHeaders) + ::abi_decode_raw(data) + .map(SegmentBedrockAndLstStrategyForkedCalls::setUp) } - getHeaders + setUp }, { fn excludeSenders( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw( data, ) - .map(FullRelayHeaviestFromAncestorTestCalls::excludeSenders) + .map(SegmentBedrockAndLstStrategyForkedCalls::excludeSenders) } excludeSenders }, @@ -8129,13 +6769,13 @@ function testUnknownRight() external; fn targetInterfaces( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw( data, ) .map( - FullRelayHeaviestFromAncestorTestCalls::targetInterfaces, + SegmentBedrockAndLstStrategyForkedCalls::targetInterfaces, ) } targetInterfaces @@ -8144,12 +6784,12 @@ function testUnknownRight() external; fn targetSenders( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw( data, ) - .map(FullRelayHeaviestFromAncestorTestCalls::targetSenders) + .map(SegmentBedrockAndLstStrategyForkedCalls::targetSenders) } targetSenders }, @@ -8157,83 +6797,59 @@ function testUnknownRight() external; fn targetContracts( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw( data, ) - .map(FullRelayHeaviestFromAncestorTestCalls::targetContracts) - } - targetContracts - }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map(FullRelayHeaviestFromAncestorTestCalls::getDigestLes) - } - getDigestLes - }, - { - fn testDescendantLeftBelowAncestor( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, - > { - ::abi_decode_raw( - data, - ) .map( - FullRelayHeaviestFromAncestorTestCalls::testDescendantLeftBelowAncestor, + SegmentBedrockAndLstStrategyForkedCalls::targetContracts, ) } - testDescendantLeftBelowAncestor + targetContracts }, { fn targetArtifactSelectors( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw( data, ) .map( - FullRelayHeaviestFromAncestorTestCalls::targetArtifactSelectors, + SegmentBedrockAndLstStrategyForkedCalls::targetArtifactSelectors, ) } targetArtifactSelectors }, { - fn testUnknownRight( + fn testSegmentSolvLstStrategy( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { - ::abi_decode_raw( + ::abi_decode_raw( data, ) .map( - FullRelayHeaviestFromAncestorTestCalls::testUnknownRight, + SegmentBedrockAndLstStrategyForkedCalls::testSegmentSolvLstStrategy, ) } - testUnknownRight + testSegmentSolvLstStrategy }, { fn targetArtifacts( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw( data, ) - .map(FullRelayHeaviestFromAncestorTestCalls::targetArtifacts) + .map( + SegmentBedrockAndLstStrategyForkedCalls::targetArtifacts, + ) } targetArtifacts }, @@ -8241,54 +6857,28 @@ function testUnknownRight() external; fn targetSelectors( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw( data, ) - .map(FullRelayHeaviestFromAncestorTestCalls::targetSelectors) - } - targetSelectors - }, - { - fn testRightIsHeavier( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, - > { - ::abi_decode_raw( - data, - ) .map( - FullRelayHeaviestFromAncestorTestCalls::testRightIsHeavier, - ) - } - testRightIsHeavier - }, - { - fn testUnknownLeft( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, - > { - ::abi_decode_raw( - data, + SegmentBedrockAndLstStrategyForkedCalls::targetSelectors, ) - .map(FullRelayHeaviestFromAncestorTestCalls::testUnknownLeft) } - testUnknownLeft + targetSelectors }, { fn excludeSelectors( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw( data, ) .map( - FullRelayHeaviestFromAncestorTestCalls::excludeSelectors, + SegmentBedrockAndLstStrategyForkedCalls::excludeSelectors, ) } excludeSelectors @@ -8297,13 +6887,13 @@ function testUnknownRight() external; fn excludeArtifacts( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw( data, ) .map( - FullRelayHeaviestFromAncestorTestCalls::excludeArtifacts, + SegmentBedrockAndLstStrategyForkedCalls::excludeArtifacts, ) } excludeArtifacts @@ -8312,96 +6902,64 @@ function testUnknownRight() external; fn failed( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw(data) - .map(FullRelayHeaviestFromAncestorTestCalls::failed) + .map(SegmentBedrockAndLstStrategyForkedCalls::failed) } failed }, - { - fn testLeftIsHeavier( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayHeaviestFromAncestorTestCalls::testLeftIsHeavier, - ) - } - testLeftIsHeavier - }, - { - fn testEqualWeightsReturnsLeft( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - FullRelayHeaviestFromAncestorTestCalls::testEqualWeightsReturnsLeft, - ) - } - testEqualWeightsReturnsLeft - }, { fn excludeContracts( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw( data, ) .map( - FullRelayHeaviestFromAncestorTestCalls::excludeContracts, + SegmentBedrockAndLstStrategyForkedCalls::excludeContracts, ) } excludeContracts }, { - fn testUnknownAncestor( + fn simulateForkAndTransfer( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { - ::abi_decode_raw( + ::abi_decode_raw( data, ) .map( - FullRelayHeaviestFromAncestorTestCalls::testUnknownAncestor, + SegmentBedrockAndLstStrategyForkedCalls::simulateForkAndTransfer, ) } - testUnknownAncestor + simulateForkAndTransfer }, { fn IS_TEST( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw(data) - .map(FullRelayHeaviestFromAncestorTestCalls::IS_TEST) + .map(SegmentBedrockAndLstStrategyForkedCalls::IS_TEST) } IS_TEST }, { - fn getBlockHeights( + fn token( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { - ::abi_decode_raw( - data, - ) - .map(FullRelayHeaviestFromAncestorTestCalls::getBlockHeights) + ::abi_decode_raw(data) + .map(SegmentBedrockAndLstStrategyForkedCalls::token) } - getBlockHeights + token }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { @@ -8422,58 +6980,45 @@ function testUnknownRight() external; ) -> alloy_sol_types::Result { static DECODE_VALIDATE_SHIMS: &[fn( &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayHeaviestFromAncestorTestCalls::getHeaderHexes) - } - getHeaderHexes - }, + ) -> alloy_sol_types::Result] = &[ { - fn testDescendantRightBelowAncestor( + fn testSegmentBedrockStrategy( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { - ::abi_decode_raw_validate( + ::abi_decode_raw_validate( data, ) .map( - FullRelayHeaviestFromAncestorTestCalls::testDescendantRightBelowAncestor, + SegmentBedrockAndLstStrategyForkedCalls::testSegmentBedrockStrategy, ) } - testDescendantRightBelowAncestor + testSegmentBedrockStrategy }, { - fn getHeaders( + fn setUp( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { - ::abi_decode_raw_validate( + ::abi_decode_raw_validate( data, ) - .map(FullRelayHeaviestFromAncestorTestCalls::getHeaders) + .map(SegmentBedrockAndLstStrategyForkedCalls::setUp) } - getHeaders + setUp }, { fn excludeSenders( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw_validate( data, ) - .map(FullRelayHeaviestFromAncestorTestCalls::excludeSenders) + .map(SegmentBedrockAndLstStrategyForkedCalls::excludeSenders) } excludeSenders }, @@ -8481,13 +7026,13 @@ function testUnknownRight() external; fn targetInterfaces( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw_validate( data, ) .map( - FullRelayHeaviestFromAncestorTestCalls::targetInterfaces, + SegmentBedrockAndLstStrategyForkedCalls::targetInterfaces, ) } targetInterfaces @@ -8496,12 +7041,12 @@ function testUnknownRight() external; fn targetSenders( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw_validate( data, ) - .map(FullRelayHeaviestFromAncestorTestCalls::targetSenders) + .map(SegmentBedrockAndLstStrategyForkedCalls::targetSenders) } targetSenders }, @@ -8509,83 +7054,59 @@ function testUnknownRight() external; fn targetContracts( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw_validate( data, ) - .map(FullRelayHeaviestFromAncestorTestCalls::targetContracts) - } - targetContracts - }, - { - fn getDigestLes( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayHeaviestFromAncestorTestCalls::getDigestLes) - } - getDigestLes - }, - { - fn testDescendantLeftBelowAncestor( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) .map( - FullRelayHeaviestFromAncestorTestCalls::testDescendantLeftBelowAncestor, + SegmentBedrockAndLstStrategyForkedCalls::targetContracts, ) } - testDescendantLeftBelowAncestor + targetContracts }, { fn targetArtifactSelectors( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw_validate( data, ) .map( - FullRelayHeaviestFromAncestorTestCalls::targetArtifactSelectors, + SegmentBedrockAndLstStrategyForkedCalls::targetArtifactSelectors, ) } targetArtifactSelectors }, { - fn testUnknownRight( + fn testSegmentSolvLstStrategy( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { - ::abi_decode_raw_validate( + ::abi_decode_raw_validate( data, ) .map( - FullRelayHeaviestFromAncestorTestCalls::testUnknownRight, + SegmentBedrockAndLstStrategyForkedCalls::testSegmentSolvLstStrategy, ) } - testUnknownRight + testSegmentSolvLstStrategy }, { fn targetArtifacts( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw_validate( data, ) - .map(FullRelayHeaviestFromAncestorTestCalls::targetArtifacts) + .map( + SegmentBedrockAndLstStrategyForkedCalls::targetArtifacts, + ) } targetArtifacts }, @@ -8593,54 +7114,28 @@ function testUnknownRight() external; fn targetSelectors( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw_validate( data, ) - .map(FullRelayHeaviestFromAncestorTestCalls::targetSelectors) - } - targetSelectors - }, - { - fn testRightIsHeavier( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) .map( - FullRelayHeaviestFromAncestorTestCalls::testRightIsHeavier, - ) - } - testRightIsHeavier - }, - { - fn testUnknownLeft( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, - > { - ::abi_decode_raw_validate( - data, + SegmentBedrockAndLstStrategyForkedCalls::targetSelectors, ) - .map(FullRelayHeaviestFromAncestorTestCalls::testUnknownLeft) } - testUnknownLeft + targetSelectors }, { fn excludeSelectors( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw_validate( data, ) .map( - FullRelayHeaviestFromAncestorTestCalls::excludeSelectors, + SegmentBedrockAndLstStrategyForkedCalls::excludeSelectors, ) } excludeSelectors @@ -8649,13 +7144,13 @@ function testUnknownRight() external; fn excludeArtifacts( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw_validate( data, ) .map( - FullRelayHeaviestFromAncestorTestCalls::excludeArtifacts, + SegmentBedrockAndLstStrategyForkedCalls::excludeArtifacts, ) } excludeArtifacts @@ -8664,100 +7159,70 @@ function testUnknownRight() external; fn failed( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw_validate( data, ) - .map(FullRelayHeaviestFromAncestorTestCalls::failed) + .map(SegmentBedrockAndLstStrategyForkedCalls::failed) } failed }, - { - fn testLeftIsHeavier( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayHeaviestFromAncestorTestCalls::testLeftIsHeavier, - ) - } - testLeftIsHeavier - }, - { - fn testEqualWeightsReturnsLeft( - data: &[u8], - ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - FullRelayHeaviestFromAncestorTestCalls::testEqualWeightsReturnsLeft, - ) - } - testEqualWeightsReturnsLeft - }, { fn excludeContracts( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw_validate( data, ) .map( - FullRelayHeaviestFromAncestorTestCalls::excludeContracts, + SegmentBedrockAndLstStrategyForkedCalls::excludeContracts, ) } excludeContracts }, { - fn testUnknownAncestor( + fn simulateForkAndTransfer( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { - ::abi_decode_raw_validate( + ::abi_decode_raw_validate( data, ) .map( - FullRelayHeaviestFromAncestorTestCalls::testUnknownAncestor, + SegmentBedrockAndLstStrategyForkedCalls::simulateForkAndTransfer, ) } - testUnknownAncestor + simulateForkAndTransfer }, { fn IS_TEST( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { ::abi_decode_raw_validate( data, ) - .map(FullRelayHeaviestFromAncestorTestCalls::IS_TEST) + .map(SegmentBedrockAndLstStrategyForkedCalls::IS_TEST) } IS_TEST }, { - fn getBlockHeights( + fn token( data: &[u8], ) -> alloy_sol_types::Result< - FullRelayHeaviestFromAncestorTestCalls, + SegmentBedrockAndLstStrategyForkedCalls, > { - ::abi_decode_raw_validate( + ::abi_decode_raw_validate( data, ) - .map(FullRelayHeaviestFromAncestorTestCalls::getBlockHeights) + .map(SegmentBedrockAndLstStrategyForkedCalls::token) } - getBlockHeights + token }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { @@ -8799,24 +7264,14 @@ function testUnknownRight() external; Self::failed(inner) => { ::abi_encoded_size(inner) } - Self::getBlockHeights(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getDigestLes(inner) => { - ::abi_encoded_size( - inner, - ) + Self::setUp(inner) => { + ::abi_encoded_size(inner) } - Self::getHeaderHexes(inner) => { - ::abi_encoded_size( + Self::simulateForkAndTransfer(inner) => { + ::abi_encoded_size( inner, ) } - Self::getHeaders(inner) => { - ::abi_encoded_size(inner) - } Self::targetArtifactSelectors(inner) => { ::abi_encoded_size( inner, @@ -8847,45 +7302,18 @@ function testUnknownRight() external; inner, ) } - Self::testDescendantLeftBelowAncestor(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testDescendantRightBelowAncestor(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testEqualWeightsReturnsLeft(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testLeftIsHeavier(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testRightIsHeavier(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testUnknownAncestor(inner) => { - ::abi_encoded_size( + Self::testSegmentBedrockStrategy(inner) => { + ::abi_encoded_size( inner, ) } - Self::testUnknownLeft(inner) => { - ::abi_encoded_size( + Self::testSegmentSolvLstStrategy(inner) => { + ::abi_encoded_size( inner, ) } - Self::testUnknownRight(inner) => { - ::abi_encoded_size( - inner, - ) + Self::token(inner) => { + ::abi_encoded_size(inner) } } } @@ -8922,26 +7350,11 @@ function testUnknownRight() external; Self::failed(inner) => { ::abi_encode_raw(inner, out) } - Self::getBlockHeights(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getDigestLes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encode_raw( - inner, - out, - ) + Self::setUp(inner) => { + ::abi_encode_raw(inner, out) } - Self::getHeaders(inner) => { - ::abi_encode_raw( + Self::simulateForkAndTransfer(inner) => { + ::abi_encode_raw( inner, out, ) @@ -8982,61 +7395,28 @@ function testUnknownRight() external; out, ) } - Self::testDescendantLeftBelowAncestor(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testDescendantRightBelowAncestor(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testEqualWeightsReturnsLeft(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testLeftIsHeavier(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testRightIsHeavier(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testUnknownAncestor(inner) => { - ::abi_encode_raw( + Self::testSegmentBedrockStrategy(inner) => { + ::abi_encode_raw( inner, out, ) } - Self::testUnknownLeft(inner) => { - ::abi_encode_raw( + Self::testSegmentSolvLstStrategy(inner) => { + ::abi_encode_raw( inner, out, ) } - Self::testUnknownRight(inner) => { - ::abi_encode_raw( - inner, - out, - ) + Self::token(inner) => { + ::abi_encode_raw(inner, out) } } } } - ///Container for all the [`FullRelayHeaviestFromAncestorTest`](self) events. + ///Container for all the [`SegmentBedrockAndLstStrategyForked`](self) events. #[derive(serde::Serialize, serde::Deserialize)] #[derive()] - pub enum FullRelayHeaviestFromAncestorTestEvents { + pub enum SegmentBedrockAndLstStrategyForkedEvents { #[allow(missing_docs)] log(log), #[allow(missing_docs)] @@ -9083,7 +7463,7 @@ function testUnknownRight() external; logs(logs), } #[automatically_derived] - impl FullRelayHeaviestFromAncestorTestEvents { + impl SegmentBedrockAndLstStrategyForkedEvents { /// All the selectors of this enum. /// /// Note that the selectors might not be in the same order as the variants. @@ -9204,8 +7584,9 @@ function testUnknownRight() external; ]; } #[automatically_derived] - impl alloy_sol_types::SolEventInterface for FullRelayHeaviestFromAncestorTestEvents { - const NAME: &'static str = "FullRelayHeaviestFromAncestorTestEvents"; + impl alloy_sol_types::SolEventInterface + for SegmentBedrockAndLstStrategyForkedEvents { + const NAME: &'static str = "SegmentBedrockAndLstStrategyForkedEvents"; const COUNT: usize = 22usize; fn decode_raw_log( topics: &[alloy_sol_types::Word], @@ -9384,7 +7765,7 @@ function testUnknownRight() external; } #[automatically_derived] impl alloy_sol_types::private::IntoLogData - for FullRelayHeaviestFromAncestorTestEvents { + for SegmentBedrockAndLstStrategyForkedEvents { fn to_log_data(&self) -> alloy_sol_types::private::LogData { match self { Self::log(inner) => { @@ -9527,9 +7908,9 @@ function testUnknownRight() external; } } use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`FullRelayHeaviestFromAncestorTest`](self) contract instance. + /**Creates a new wrapper around an on-chain [`SegmentBedrockAndLstStrategyForked`](self) contract instance. -See the [wrapper's documentation](`FullRelayHeaviestFromAncestorTestInstance`) for more details.*/ +See the [wrapper's documentation](`SegmentBedrockAndLstStrategyForkedInstance`) for more details.*/ #[inline] pub const fn new< P: alloy_contract::private::Provider, @@ -9537,8 +7918,8 @@ See the [wrapper's documentation](`FullRelayHeaviestFromAncestorTestInstance`) f >( address: alloy_sol_types::private::Address, provider: P, - ) -> FullRelayHeaviestFromAncestorTestInstance { - FullRelayHeaviestFromAncestorTestInstance::::new(address, provider) + ) -> SegmentBedrockAndLstStrategyForkedInstance { + SegmentBedrockAndLstStrategyForkedInstance::::new(address, provider) } /**Deploys this contract using the given `provider` and constructor arguments, if any. @@ -9552,9 +7933,9 @@ For more fine-grained control over the deployment process, use [`deploy_builder` >( provider: P, ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, + Output = alloy_contract::Result>, > { - FullRelayHeaviestFromAncestorTestInstance::::deploy(provider) + SegmentBedrockAndLstStrategyForkedInstance::::deploy(provider) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` and constructor arguments, if any. @@ -9566,12 +7947,12 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ P: alloy_contract::private::Provider, N: alloy_contract::private::Network, >(provider: P) -> alloy_contract::RawCallBuilder { - FullRelayHeaviestFromAncestorTestInstance::::deploy_builder(provider) + SegmentBedrockAndLstStrategyForkedInstance::::deploy_builder(provider) } - /**A [`FullRelayHeaviestFromAncestorTest`](self) instance. + /**A [`SegmentBedrockAndLstStrategyForked`](self) instance. Contains type-safe methods for interacting with an on-chain instance of the -[`FullRelayHeaviestFromAncestorTest`](self) contract located at a given `address`, using a given +[`SegmentBedrockAndLstStrategyForked`](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!) @@ -9580,7 +7961,7 @@ 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 FullRelayHeaviestFromAncestorTestInstance< + pub struct SegmentBedrockAndLstStrategyForkedInstance< P, N = alloy_contract::private::Ethereum, > { @@ -9589,10 +7970,10 @@ See the [module-level documentation](self) for all the available methods.*/ _network: ::core::marker::PhantomData, } #[automatically_derived] - impl ::core::fmt::Debug for FullRelayHeaviestFromAncestorTestInstance { + impl ::core::fmt::Debug for SegmentBedrockAndLstStrategyForkedInstance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("FullRelayHeaviestFromAncestorTestInstance") + f.debug_tuple("SegmentBedrockAndLstStrategyForkedInstance") .field(&self.address) .finish() } @@ -9602,10 +7983,10 @@ See the [module-level documentation](self) for all the available methods.*/ impl< P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - > FullRelayHeaviestFromAncestorTestInstance { - /**Creates a new wrapper around an on-chain [`FullRelayHeaviestFromAncestorTest`](self) contract instance. + > SegmentBedrockAndLstStrategyForkedInstance { + /**Creates a new wrapper around an on-chain [`SegmentBedrockAndLstStrategyForked`](self) contract instance. -See the [wrapper's documentation](`FullRelayHeaviestFromAncestorTestInstance`) for more details.*/ +See the [wrapper's documentation](`SegmentBedrockAndLstStrategyForkedInstance`) for more details.*/ #[inline] pub const fn new( address: alloy_sol_types::private::Address, @@ -9625,7 +8006,7 @@ For more fine-grained control over the deployment process, use [`deploy_builder` #[inline] pub async fn deploy( provider: P, - ) -> alloy_contract::Result> { + ) -> alloy_contract::Result> { let call_builder = Self::deploy_builder(provider); let contract_address = call_builder.deploy().await?; Ok(Self::new(contract_address, call_builder.provider)) @@ -9663,13 +8044,13 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ &self.provider } } - impl FullRelayHeaviestFromAncestorTestInstance<&P, N> { + impl SegmentBedrockAndLstStrategyForkedInstance<&P, N> { /// Clones the provider and returns a new instance with the cloned provider. #[inline] pub fn with_cloned_provider( self, - ) -> FullRelayHeaviestFromAncestorTestInstance { - FullRelayHeaviestFromAncestorTestInstance { + ) -> SegmentBedrockAndLstStrategyForkedInstance { + SegmentBedrockAndLstStrategyForkedInstance { address: self.address, provider: ::core::clone::Clone::clone(&self.provider), _network: ::core::marker::PhantomData, @@ -9681,7 +8062,7 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ impl< P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - > FullRelayHeaviestFromAncestorTestInstance { + > SegmentBedrockAndLstStrategyForkedInstance { /// 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 @@ -9724,63 +8105,24 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { self.call_builder(&failedCall) } - ///Creates a new call builder for the [`getBlockHeights`] function. - pub fn getBlockHeights( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getBlockHeightsCall, N> { - self.call_builder( - &getBlockHeightsCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getDigestLes`] function. - pub fn getDigestLes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getDigestLesCall, N> { - self.call_builder( - &getDigestLesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaderHexes`] function. - pub fn getHeaderHexes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeaderHexesCall, N> { - self.call_builder( - &getHeaderHexesCall { - chainName, - from, - to, - }, - ) + ///Creates a new call builder for the [`setUp`] function. + pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { + self.call_builder(&setUpCall) } - ///Creates a new call builder for the [`getHeaders`] function. - pub fn getHeaders( + ///Creates a new call builder for the [`simulateForkAndTransfer`] function. + pub fn simulateForkAndTransfer( &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeadersCall, N> { + forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + sender: alloy::sol_types::private::Address, + receiver: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { self.call_builder( - &getHeadersCall { - chainName, - from, - to, + &simulateForkAndTransferCall { + forkAtBlock, + sender, + receiver, + amount, }, ) } @@ -9820,57 +8162,21 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { self.call_builder(&targetSendersCall) } - ///Creates a new call builder for the [`testDescendantLeftBelowAncestor`] function. - pub fn testDescendantLeftBelowAncestor( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testDescendantLeftBelowAncestorCall, N> { - self.call_builder(&testDescendantLeftBelowAncestorCall) - } - ///Creates a new call builder for the [`testDescendantRightBelowAncestor`] function. - pub fn testDescendantRightBelowAncestor( + ///Creates a new call builder for the [`testSegmentBedrockStrategy`] function. + pub fn testSegmentBedrockStrategy( &self, - ) -> alloy_contract::SolCallBuilder< - &P, - testDescendantRightBelowAncestorCall, - N, - > { - self.call_builder(&testDescendantRightBelowAncestorCall) - } - ///Creates a new call builder for the [`testEqualWeightsReturnsLeft`] function. - pub fn testEqualWeightsReturnsLeft( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testEqualWeightsReturnsLeftCall, N> { - self.call_builder(&testEqualWeightsReturnsLeftCall) - } - ///Creates a new call builder for the [`testLeftIsHeavier`] function. - pub fn testLeftIsHeavier( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testLeftIsHeavierCall, N> { - self.call_builder(&testLeftIsHeavierCall) - } - ///Creates a new call builder for the [`testRightIsHeavier`] function. - pub fn testRightIsHeavier( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testRightIsHeavierCall, N> { - self.call_builder(&testRightIsHeavierCall) - } - ///Creates a new call builder for the [`testUnknownAncestor`] function. - pub fn testUnknownAncestor( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testUnknownAncestorCall, N> { - self.call_builder(&testUnknownAncestorCall) + ) -> alloy_contract::SolCallBuilder<&P, testSegmentBedrockStrategyCall, N> { + self.call_builder(&testSegmentBedrockStrategyCall) } - ///Creates a new call builder for the [`testUnknownLeft`] function. - pub fn testUnknownLeft( + ///Creates a new call builder for the [`testSegmentSolvLstStrategy`] function. + pub fn testSegmentSolvLstStrategy( &self, - ) -> alloy_contract::SolCallBuilder<&P, testUnknownLeftCall, N> { - self.call_builder(&testUnknownLeftCall) + ) -> alloy_contract::SolCallBuilder<&P, testSegmentSolvLstStrategyCall, N> { + self.call_builder(&testSegmentSolvLstStrategyCall) } - ///Creates a new call builder for the [`testUnknownRight`] function. - pub fn testUnknownRight( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testUnknownRightCall, N> { - self.call_builder(&testUnknownRightCall) + ///Creates a new call builder for the [`token`] function. + pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { + self.call_builder(&tokenCall) } } /// Event filters. @@ -9878,7 +8184,7 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ impl< P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - > FullRelayHeaviestFromAncestorTestInstance { + > SegmentBedrockAndLstStrategyForkedInstance { /// 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. diff --git a/crates/bindings/src/segment_bedrock_strategy.rs b/crates/bindings/src/segment_bedrock_strategy.rs new file mode 100644 index 000000000..b8766c3c9 --- /dev/null +++ b/crates/bindings/src/segment_bedrock_strategy.rs @@ -0,0 +1,1810 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface SegmentBedrockStrategy { + struct StrategySlippageArgs { + uint256 amountOutMin; + } + + event TokenOutput(address tokenReceived, uint256 amountOut); + + constructor(address _bedrockStrategy, address _segmentStrategy); + + function bedrockStrategy() external view returns (address); + function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; + function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amount, address recipient, StrategySlippageArgs memory args) external; + function segmentStrategy() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_bedrockStrategy", + "type": "address", + "internalType": "contract BedrockStrategy" + }, + { + "name": "_segmentStrategy", + "type": "address", + "internalType": "contract SegmentStrategy" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "bedrockStrategy", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract BedrockStrategy" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "handleGatewayMessage", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "message", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessageWithSlippageArgs", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "args", + "type": "tuple", + "internalType": "struct StrategySlippageArgs", + "components": [ + { + "name": "amountOutMin", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "segmentStrategy", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract SegmentStrategy" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "TokenOutput", + "inputs": [ + { + "name": "tokenReceived", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "amountOut", + "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 SegmentBedrockStrategy { + use super::*; + use alloy::sol_types as 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\r\x8C8\x03\x80a\r\x8C\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\xB6a\0\xD6_9_\x81\x81`\xCB\x01R\x81\x81a\x03\xE1\x01Ra\x04a\x01R_\x81\x81`S\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0C\xB6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c#\x17\x10\xA5\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xB0\xF1\xE3u\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\n=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFB\xFAw\xCF`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B\xA6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x0EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x032\x91\x90a\x0B\xA6V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xC3\x91\x90a\x0B\xC1V[\x90Pa\x04\x06s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x84V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xA2W__\xFD[PZ\xF1\x15\x80\x15a\x04\xB4W=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05~\x90\x85\x90\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\x90`\x84\x01[`@\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\x7FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1C\x91\x90a\x0B\xC1V[a\x06&\x91\x90a\x0B\xD8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05~\x90\x85\x90\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\x90`d\x01a\x05\x1AV[_a\x06\xE0\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\x07\x94\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\x8FW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFE\x91\x90a\x0C\x16V[a\x07\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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x07\xA2\x84\x84_\x85a\x07\xACV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08>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\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\x07\x86V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\xBCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x86V[__\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\x08\xE4\x91\x90a\x0C5V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\t\x1EW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t#V[``\x91P[P\x91P\x91Pa\t3\x82\x82\x86a\t>V[\x97\x96PPPPPPPV[``\x83\x15a\tMWP\x81a\x07\xA5V[\x82Q\x15a\t]W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x86\x91\x90a\x0CKV[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\t\xB2W__\xFD[PV[\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\n\x05Wa\n\x05a\t\xB5V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n4Wa\n4a\t\xB5V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\nOW__\xFD[\x845a\nZ\x81a\t\x91V[\x93P` \x85\x015\x92P`@\x85\x015a\nq\x81a\t\x91V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x8CW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x9CW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xB6Wa\n\xB6a\t\xB5V[a\n\xC9` `\x1F\x19`\x1F\x84\x01\x16\x01a\n\x0BV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n\xDDW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0B\x12W__\xFD[\x855a\x0B\x1D\x81a\t\x91V[\x94P` \x86\x015\x93P`@\x86\x015a\x0B4\x81a\t\x91V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0BeW__\xFD[Pa\x0Bna\t\xE2V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x93W__\xFD[Pa\x0B\x9Ca\t\xE2V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xB6W__\xFD[\x81Qa\x07\xA5\x81a\t\x91V[_` \x82\x84\x03\x12\x15a\x0B\xD1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0C\x10W\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[_` \x82\x84\x03\x12\x15a\x0C&W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\xA5W__\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\xFE\xA2dipfsX\"\x12 \xC8o\xCDB\x03\x85\xE3\xD8\xE52\x96F\x87\xCC\x1Eo\xE7\xC4i\x88\x13fC'6\x1Dq);\xA3\xF6ydsolcC\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#\x17\x10\xA5\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xB0\xF1\xE3u\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\n=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFB\xFAw\xCF`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B\xA6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x0EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x032\x91\x90a\x0B\xA6V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xC3\x91\x90a\x0B\xC1V[\x90Pa\x04\x06s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x84V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xA2W__\xFD[PZ\xF1\x15\x80\x15a\x04\xB4W=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05~\x90\x85\x90\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\x90`\x84\x01[`@\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\x7FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1C\x91\x90a\x0B\xC1V[a\x06&\x91\x90a\x0B\xD8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05~\x90\x85\x90\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\x90`d\x01a\x05\x1AV[_a\x06\xE0\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\x07\x94\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\x8FW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFE\x91\x90a\x0C\x16V[a\x07\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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x07\xA2\x84\x84_\x85a\x07\xACV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08>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\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\x07\x86V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\xBCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x86V[__\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\x08\xE4\x91\x90a\x0C5V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\t\x1EW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t#V[``\x91P[P\x91P\x91Pa\t3\x82\x82\x86a\t>V[\x97\x96PPPPPPPV[``\x83\x15a\tMWP\x81a\x07\xA5V[\x82Q\x15a\t]W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x86\x91\x90a\x0CKV[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\t\xB2W__\xFD[PV[\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\n\x05Wa\n\x05a\t\xB5V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n4Wa\n4a\t\xB5V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\nOW__\xFD[\x845a\nZ\x81a\t\x91V[\x93P` \x85\x015\x92P`@\x85\x015a\nq\x81a\t\x91V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x8CW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x9CW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xB6Wa\n\xB6a\t\xB5V[a\n\xC9` `\x1F\x19`\x1F\x84\x01\x16\x01a\n\x0BV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n\xDDW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0B\x12W__\xFD[\x855a\x0B\x1D\x81a\t\x91V[\x94P` \x86\x015\x93P`@\x86\x015a\x0B4\x81a\t\x91V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0BeW__\xFD[Pa\x0Bna\t\xE2V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x93W__\xFD[Pa\x0B\x9Ca\t\xE2V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xB6W__\xFD[\x81Qa\x07\xA5\x81a\t\x91V[_` \x82\x84\x03\x12\x15a\x0B\xD1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0C\x10W\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[_` \x82\x84\x03\x12\x15a\x0C&W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\xA5W__\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\xFE\xA2dipfsX\"\x12 \xC8o\xCDB\x03\x85\xE3\xD8\xE52\x96F\x87\xCC\x1Eo\xE7\xC4i\x88\x13fC'6\x1Dq);\xA3\xF6ydsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct StrategySlippageArgs { uint256 amountOutMin; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct StrategySlippageArgs { + #[allow(missing_docs)] + pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: StrategySlippageArgs) -> Self { + (value.amountOutMin,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for StrategySlippageArgs { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { amountOutMin: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for StrategySlippageArgs { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for StrategySlippageArgs { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for StrategySlippageArgs { + const NAME: &'static str = "StrategySlippageArgs"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "StrategySlippageArgs(uint256 amountOutMin)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) + .0 + .to_vec() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for StrategySlippageArgs { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.amountOutMin, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.amountOutMin, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. +```solidity +event TokenOutput(address tokenReceived, uint256 amountOut); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct TokenOutput { + #[allow(missing_docs)] + pub tokenReceived: alloy::sol_types::private::Address, + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for TokenOutput { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + tokenReceived: data.0, + amountOut: data.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.tokenReceived, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountOut), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 TokenOutput { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&TokenOutput> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(address _bedrockStrategy, address _segmentStrategy); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _bedrockStrategy: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _segmentStrategy: alloy::sol_types::private::Address, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._bedrockStrategy, value._segmentStrategy) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _bedrockStrategy: tuple.0, + _segmentStrategy: 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> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._bedrockStrategy, + ), + ::tokenize( + &self._segmentStrategy, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `bedrockStrategy()` and selector `0x231710a5`. +```solidity +function bedrockStrategy() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct bedrockStrategyCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`bedrockStrategy()`](bedrockStrategyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct bedrockStrategyReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: bedrockStrategyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for bedrockStrategyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: bedrockStrategyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for bedrockStrategyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for bedrockStrategyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "bedrockStrategy()"; + const SELECTOR: [u8; 4] = [35u8, 23u8, 16u8, 165u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: bedrockStrategyReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: bedrockStrategyReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. +```solidity +function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub message: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ); + #[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, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.message) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + message: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageCall { + 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, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; + const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.message, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. +```solidity +function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amount, address recipient, StrategySlippageArgs memory args) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub args: ::RustType, + } + ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Address, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { + (value.tokenSent, value.amount, value.recipient, value.args) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amount: tuple.1, + recipient: tuple.2, + args: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageWithSlippageArgsReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageWithSlippageArgsReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; + const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.args, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `segmentStrategy()` and selector `0xb0f1e375`. +```solidity +function segmentStrategy() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct segmentStrategyCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`segmentStrategy()`](segmentStrategyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct segmentStrategyReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: segmentStrategyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for segmentStrategyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: segmentStrategyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for segmentStrategyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for segmentStrategyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "segmentStrategy()"; + const SELECTOR: [u8; 4] = [176u8, 241u8, 227u8, 117u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: segmentStrategyReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: segmentStrategyReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`SegmentBedrockStrategy`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum SegmentBedrockStrategyCalls { + #[allow(missing_docs)] + bedrockStrategy(bedrockStrategyCall), + #[allow(missing_docs)] + handleGatewayMessage(handleGatewayMessageCall), + #[allow(missing_docs)] + handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), + #[allow(missing_docs)] + segmentStrategy(segmentStrategyCall), + } + #[automatically_derived] + impl SegmentBedrockStrategyCalls { + /// 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]] = &[ + [35u8, 23u8, 16u8, 165u8], + [80u8, 99u8, 76u8, 14u8], + [127u8, 129u8, 79u8, 53u8], + [176u8, 241u8, 227u8, 117u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for SegmentBedrockStrategyCalls { + const NAME: &'static str = "SegmentBedrockStrategyCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 4usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::bedrockStrategy(_) => { + ::SELECTOR + } + Self::handleGatewayMessage(_) => { + ::SELECTOR + } + Self::handleGatewayMessageWithSlippageArgs(_) => { + ::SELECTOR + } + Self::segmentStrategy(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn bedrockStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SegmentBedrockStrategyCalls::bedrockStrategy) + } + bedrockStrategy + }, + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SegmentBedrockStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + SegmentBedrockStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + { + fn segmentStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SegmentBedrockStrategyCalls::segmentStrategy) + } + segmentStrategy + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn bedrockStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentBedrockStrategyCalls::bedrockStrategy) + } + bedrockStrategy + }, + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentBedrockStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + SegmentBedrockStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + { + fn segmentStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentBedrockStrategyCalls::segmentStrategy) + } + segmentStrategy + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::bedrockStrategy(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::handleGatewayMessage(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::segmentStrategy(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::bedrockStrategy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::handleGatewayMessage(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::segmentStrategy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`SegmentBedrockStrategy`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum SegmentBedrockStrategyEvents { + #[allow(missing_docs)] + TokenOutput(TokenOutput), + } + #[automatically_derived] + impl SegmentBedrockStrategyEvents { + /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for SegmentBedrockStrategyEvents { + const NAME: &'static str = "SegmentBedrockStrategyEvents"; + const COUNT: usize = 1usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::TokenOutput) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 SegmentBedrockStrategyEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`SegmentBedrockStrategy`](self) contract instance. + +See the [wrapper's documentation](`SegmentBedrockStrategyInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> SegmentBedrockStrategyInstance { + SegmentBedrockStrategyInstance::::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: alloy_contract::private::Network, + >( + provider: P, + _bedrockStrategy: alloy::sol_types::private::Address, + _segmentStrategy: alloy::sol_types::private::Address, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + SegmentBedrockStrategyInstance::< + P, + N, + >::deploy(provider, _bedrockStrategy, _segmentStrategy) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + _bedrockStrategy: alloy::sol_types::private::Address, + _segmentStrategy: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + SegmentBedrockStrategyInstance::< + P, + N, + >::deploy_builder(provider, _bedrockStrategy, _segmentStrategy) + } + /**A [`SegmentBedrockStrategy`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`SegmentBedrockStrategy`](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 SegmentBedrockStrategyInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for SegmentBedrockStrategyInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("SegmentBedrockStrategyInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SegmentBedrockStrategyInstance { + /**Creates a new wrapper around an on-chain [`SegmentBedrockStrategy`](self) contract instance. + +See the [wrapper's documentation](`SegmentBedrockStrategyInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + _bedrockStrategy: alloy::sol_types::private::Address, + _segmentStrategy: alloy::sol_types::private::Address, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder( + provider, + _bedrockStrategy, + _segmentStrategy, + ); + 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, + _bedrockStrategy: alloy::sol_types::private::Address, + _segmentStrategy: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + _bedrockStrategy, + _segmentStrategy, + }, + )[..], + ] + .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 SegmentBedrockStrategyInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> SegmentBedrockStrategyInstance { + SegmentBedrockStrategyInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SegmentBedrockStrategyInstance { + /// 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( + &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 [`bedrockStrategy`] function. + pub fn bedrockStrategy( + &self, + ) -> alloy_contract::SolCallBuilder<&P, bedrockStrategyCall, N> { + self.call_builder(&bedrockStrategyCall) + } + ///Creates a new call builder for the [`handleGatewayMessage`] function. + pub fn handleGatewayMessage( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + message: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { + self.call_builder( + &handleGatewayMessageCall { + tokenSent, + amountIn, + recipient, + message, + }, + ) + } + ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. + pub fn handleGatewayMessageWithSlippageArgs( + &self, + tokenSent: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + args: ::RustType, + ) -> alloy_contract::SolCallBuilder< + &P, + handleGatewayMessageWithSlippageArgsCall, + N, + > { + self.call_builder( + &handleGatewayMessageWithSlippageArgsCall { + tokenSent, + amount, + recipient, + args, + }, + ) + } + ///Creates a new call builder for the [`segmentStrategy`] function. + pub fn segmentStrategy( + &self, + ) -> alloy_contract::SolCallBuilder<&P, segmentStrategyCall, N> { + self.call_builder(&segmentStrategyCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SegmentBedrockStrategyInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`TokenOutput`] event. + pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/segment_solv_lst_strategy.rs b/crates/bindings/src/segment_solv_lst_strategy.rs new file mode 100644 index 000000000..748bf9cd5 --- /dev/null +++ b/crates/bindings/src/segment_solv_lst_strategy.rs @@ -0,0 +1,1810 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface SegmentSolvLSTStrategy { + struct StrategySlippageArgs { + uint256 amountOutMin; + } + + event TokenOutput(address tokenReceived, uint256 amountOut); + + constructor(address _solvLSTStrategy, address _segmentStrategy); + + function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; + function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amount, address recipient, StrategySlippageArgs memory args) external; + function segmentStrategy() external view returns (address); + function solvLSTStrategy() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_solvLSTStrategy", + "type": "address", + "internalType": "contract SolvLSTStrategy" + }, + { + "name": "_segmentStrategy", + "type": "address", + "internalType": "contract SegmentStrategy" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessage", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "message", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessageWithSlippageArgs", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "args", + "type": "tuple", + "internalType": "struct StrategySlippageArgs", + "components": [ + { + "name": "amountOutMin", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "segmentStrategy", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract SegmentStrategy" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "solvLSTStrategy", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract SolvLSTStrategy" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "TokenOutput", + "inputs": [ + { + "name": "tokenReceived", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "amountOut", + "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 SegmentSolvLSTStrategy { + use super::*; + use alloy::sol_types as 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\r 8\x03\x80a\r \x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CJa\0\xD6_9_\x81\x81`{\x01R\x81\x81a\x03u\x01Ra\x03\xF5\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0CJ_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cPcL\x0E\x14a\0NW\x80c\x7F\x81O5\x14a\0cW\x80c\xB0\xF1\xE3u\x14a\0vW\x80c\xF2#L\xF9\x14a\0\xC6W[__\xFD[a\0aa\0\\6`\x04a\t\xD0V[a\0\xEDV[\0[a\0aa\0q6`\x04a\n\x92V[a\x01\x17V[a\0\x9D\x7F\0\0\0\0\0\0\0\0\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\x9D\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 \"\x8F\x03\x84\x07\x19t\xAAf\xF7u\xC6\x06\xB7\xDD\x8B\x8AKq\xA1\x9E<9!\xA2\xDD\xC4}\xE1\xC4\xDAcdsolcC\0\x08\x1C\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x608060405234801561000f575f5ffd5b506004361061004a575f3560e01c806350634c0e1461004e5780637f814f3514610063578063b0f1e37514610076578063f2234cf9146100c6575b5f5ffd5b61006161005c3660046109d0565b6100ed565b005b610061610071366004610a92565b610117565b61009d7f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200160405180910390f35b61009d7f000000000000000000000000000000000000000000000000000000000000000081565b5f818060200190518101906101029190610b16565b905061011085858584610117565b5050505050565b61013973ffffffffffffffffffffffffffffffffffffffff8516333086610454565b61017a73ffffffffffffffffffffffffffffffffffffffff85167f000000000000000000000000000000000000000000000000000000000000000085610518565b604080516020810182525f815290517f7f814f3500000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff868116600483015260248201869052306044830152915160648201527f000000000000000000000000000000000000000000000000000000000000000090911690637f814f35906084015f604051808303815f87803b158015610222575f5ffd5b505af1158015610234573d5f5f3e3d5ffd5b505050505f7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663ad747de66040518163ffffffff1660e01b8152600401602060405180830381865afa1580156102a2573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906102c69190610b3a565b6040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201529091505f9073ffffffffffffffffffffffffffffffffffffffff8316906370a0823190602401602060405180830381865afa158015610333573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103579190610b55565b905061039a73ffffffffffffffffffffffffffffffffffffffff83167f000000000000000000000000000000000000000000000000000000000000000083610518565b6040517f7f814f3500000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8381166004830152602482018390528581166044830152845160648301527f00000000000000000000000000000000000000000000000000000000000000001690637f814f35906084015f604051808303815f87803b158015610436575f5ffd5b505af1158015610448573d5f5f3e3d5ffd5b50505050505050505050565b60405173ffffffffffffffffffffffffffffffffffffffff808516602483015283166044820152606481018290526105129085907f23b872dd00000000000000000000000000000000000000000000000000000000906084015b60408051601f198184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff0000000000000000000000000000000000000000000000000000000090931692909217909152610613565b50505050565b6040517fdd62ed3e00000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff83811660248301525f91839186169063dd62ed3e90604401602060405180830381865afa15801561058c573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906105b09190610b55565b6105ba9190610b6c565b60405173ffffffffffffffffffffffffffffffffffffffff85166024820152604481018290529091506105129085907f095ea7b300000000000000000000000000000000000000000000000000000000906064016104ae565b5f610674826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166107289092919063ffffffff16565b80519091501561072357808060200190518101906106929190610baa565b610723576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f7420737563636565640000000000000000000000000000000000000000000060648201526084015b60405180910390fd5b505050565b606061073684845f85610740565b90505b9392505050565b6060824710156107d2576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c0000000000000000000000000000000000000000000000000000606482015260840161071a565b73ffffffffffffffffffffffffffffffffffffffff85163b610850576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015260640161071a565b5f5f8673ffffffffffffffffffffffffffffffffffffffff1685876040516108789190610bc9565b5f6040518083038185875af1925050503d805f81146108b2576040519150601f19603f3d011682016040523d82523d5f602084013e6108b7565b606091505b50915091506108c78282866108d2565b979650505050505050565b606083156108e1575081610739565b8251156108f15782518084602001fd5b816040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161071a9190610bdf565b73ffffffffffffffffffffffffffffffffffffffff81168114610946575f5ffd5b50565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b6040516020810167ffffffffffffffff8111828210171561099957610999610949565b60405290565b604051601f8201601f1916810167ffffffffffffffff811182821017156109c8576109c8610949565b604052919050565b5f5f5f5f608085870312156109e3575f5ffd5b84356109ee81610925565b9350602085013592506040850135610a0581610925565b9150606085013567ffffffffffffffff811115610a20575f5ffd5b8501601f81018713610a30575f5ffd5b803567ffffffffffffffff811115610a4a57610a4a610949565b610a5d6020601f19601f8401160161099f565b818152886020838501011115610a71575f5ffd5b816020840160208301375f6020838301015280935050505092959194509250565b5f5f5f5f8486036080811215610aa6575f5ffd5b8535610ab181610925565b9450602086013593506040860135610ac881610925565b925060207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa082011215610af9575f5ffd5b50610b02610976565b606095909501358552509194909350909190565b5f6020828403128015610b27575f5ffd5b50610b30610976565b9151825250919050565b5f60208284031215610b4a575f5ffd5b815161073981610925565b5f60208284031215610b65575f5ffd5b5051919050565b80820180821115610ba4577f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b92915050565b5f60208284031215610bba575f5ffd5b81518015158114610739575f5ffd5b5f82518060208501845e5f920191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f8301168401019150509291505056fea2646970667358221220228f0384071974aa66f775c606b7dd8b8a4b71a19e3c3921a2ddc47de1c4da6364736f6c634300081c0033 + /// ``` + #[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\x80cPcL\x0E\x14a\0NW\x80c\x7F\x81O5\x14a\0cW\x80c\xB0\xF1\xE3u\x14a\0vW\x80c\xF2#L\xF9\x14a\0\xC6W[__\xFD[a\0aa\0\\6`\x04a\t\xD0V[a\0\xEDV[\0[a\0aa\0q6`\x04a\n\x92V[a\x01\x17V[a\0\x9D\x7F\0\0\0\0\0\0\0\0\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\x9D\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 \"\x8F\x03\x84\x07\x19t\xAAf\xF7u\xC6\x06\xB7\xDD\x8B\x8AKq\xA1\x9E<9!\xA2\xDD\xC4}\xE1\xC4\xDAcdsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct StrategySlippageArgs { uint256 amountOutMin; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct StrategySlippageArgs { + #[allow(missing_docs)] + pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: StrategySlippageArgs) -> Self { + (value.amountOutMin,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for StrategySlippageArgs { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { amountOutMin: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for StrategySlippageArgs { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for StrategySlippageArgs { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for StrategySlippageArgs { + const NAME: &'static str = "StrategySlippageArgs"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "StrategySlippageArgs(uint256 amountOutMin)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) + .0 + .to_vec() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for StrategySlippageArgs { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.amountOutMin, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.amountOutMin, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. +```solidity +event TokenOutput(address tokenReceived, uint256 amountOut); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct TokenOutput { + #[allow(missing_docs)] + pub tokenReceived: alloy::sol_types::private::Address, + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for TokenOutput { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + tokenReceived: data.0, + amountOut: data.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.tokenReceived, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountOut), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 TokenOutput { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&TokenOutput> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(address _solvLSTStrategy, address _segmentStrategy); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _solvLSTStrategy: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _segmentStrategy: alloy::sol_types::private::Address, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._solvLSTStrategy, value._segmentStrategy) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _solvLSTStrategy: tuple.0, + _segmentStrategy: 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> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._solvLSTStrategy, + ), + ::tokenize( + &self._segmentStrategy, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. +```solidity +function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub message: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ); + #[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, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.message) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + message: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageCall { + 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, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; + const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.message, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. +```solidity +function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amount, address recipient, StrategySlippageArgs memory args) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amount: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub args: ::RustType, + } + ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Address, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { + (value.tokenSent, value.amount, value.recipient, value.args) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amount: tuple.1, + recipient: tuple.2, + args: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageWithSlippageArgsReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageWithSlippageArgsReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; + const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.args, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `segmentStrategy()` and selector `0xb0f1e375`. +```solidity +function segmentStrategy() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct segmentStrategyCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`segmentStrategy()`](segmentStrategyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct segmentStrategyReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: segmentStrategyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for segmentStrategyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: segmentStrategyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for segmentStrategyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for segmentStrategyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "segmentStrategy()"; + const SELECTOR: [u8; 4] = [176u8, 241u8, 227u8, 117u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: segmentStrategyReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: segmentStrategyReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `solvLSTStrategy()` and selector `0xf2234cf9`. +```solidity +function solvLSTStrategy() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct solvLSTStrategyCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`solvLSTStrategy()`](solvLSTStrategyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct solvLSTStrategyReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: solvLSTStrategyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for solvLSTStrategyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: solvLSTStrategyReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for solvLSTStrategyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for solvLSTStrategyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "solvLSTStrategy()"; + const SELECTOR: [u8; 4] = [242u8, 35u8, 76u8, 249u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: solvLSTStrategyReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: solvLSTStrategyReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`SegmentSolvLSTStrategy`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum SegmentSolvLSTStrategyCalls { + #[allow(missing_docs)] + handleGatewayMessage(handleGatewayMessageCall), + #[allow(missing_docs)] + handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), + #[allow(missing_docs)] + segmentStrategy(segmentStrategyCall), + #[allow(missing_docs)] + solvLSTStrategy(solvLSTStrategyCall), + } + #[automatically_derived] + impl SegmentSolvLSTStrategyCalls { + /// 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, 99u8, 76u8, 14u8], + [127u8, 129u8, 79u8, 53u8], + [176u8, 241u8, 227u8, 117u8], + [242u8, 35u8, 76u8, 249u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for SegmentSolvLSTStrategyCalls { + const NAME: &'static str = "SegmentSolvLSTStrategyCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 4usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::handleGatewayMessage(_) => { + ::SELECTOR + } + Self::handleGatewayMessageWithSlippageArgs(_) => { + ::SELECTOR + } + Self::segmentStrategy(_) => { + ::SELECTOR + } + Self::solvLSTStrategy(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SegmentSolvLSTStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + SegmentSolvLSTStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + { + fn segmentStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SegmentSolvLSTStrategyCalls::segmentStrategy) + } + segmentStrategy + }, + { + fn solvLSTStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SegmentSolvLSTStrategyCalls::solvLSTStrategy) + } + solvLSTStrategy + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentSolvLSTStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + SegmentSolvLSTStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + { + fn segmentStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentSolvLSTStrategyCalls::segmentStrategy) + } + segmentStrategy + }, + { + fn solvLSTStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentSolvLSTStrategyCalls::solvLSTStrategy) + } + solvLSTStrategy + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::handleGatewayMessage(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::segmentStrategy(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::solvLSTStrategy(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::handleGatewayMessage(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::segmentStrategy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::solvLSTStrategy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`SegmentSolvLSTStrategy`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum SegmentSolvLSTStrategyEvents { + #[allow(missing_docs)] + TokenOutput(TokenOutput), + } + #[automatically_derived] + impl SegmentSolvLSTStrategyEvents { + /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for SegmentSolvLSTStrategyEvents { + const NAME: &'static str = "SegmentSolvLSTStrategyEvents"; + const COUNT: usize = 1usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::TokenOutput) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 SegmentSolvLSTStrategyEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`SegmentSolvLSTStrategy`](self) contract instance. + +See the [wrapper's documentation](`SegmentSolvLSTStrategyInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> SegmentSolvLSTStrategyInstance { + SegmentSolvLSTStrategyInstance::::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: alloy_contract::private::Network, + >( + provider: P, + _solvLSTStrategy: alloy::sol_types::private::Address, + _segmentStrategy: alloy::sol_types::private::Address, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + SegmentSolvLSTStrategyInstance::< + P, + N, + >::deploy(provider, _solvLSTStrategy, _segmentStrategy) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + _solvLSTStrategy: alloy::sol_types::private::Address, + _segmentStrategy: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + SegmentSolvLSTStrategyInstance::< + P, + N, + >::deploy_builder(provider, _solvLSTStrategy, _segmentStrategy) + } + /**A [`SegmentSolvLSTStrategy`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`SegmentSolvLSTStrategy`](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 SegmentSolvLSTStrategyInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for SegmentSolvLSTStrategyInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("SegmentSolvLSTStrategyInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SegmentSolvLSTStrategyInstance { + /**Creates a new wrapper around an on-chain [`SegmentSolvLSTStrategy`](self) contract instance. + +See the [wrapper's documentation](`SegmentSolvLSTStrategyInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + _solvLSTStrategy: alloy::sol_types::private::Address, + _segmentStrategy: alloy::sol_types::private::Address, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder( + provider, + _solvLSTStrategy, + _segmentStrategy, + ); + 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, + _solvLSTStrategy: alloy::sol_types::private::Address, + _segmentStrategy: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + _solvLSTStrategy, + _segmentStrategy, + }, + )[..], + ] + .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 SegmentSolvLSTStrategyInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> SegmentSolvLSTStrategyInstance { + SegmentSolvLSTStrategyInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SegmentSolvLSTStrategyInstance { + /// 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( + &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 [`handleGatewayMessage`] function. + pub fn handleGatewayMessage( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + message: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { + self.call_builder( + &handleGatewayMessageCall { + tokenSent, + amountIn, + recipient, + message, + }, + ) + } + ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. + pub fn handleGatewayMessageWithSlippageArgs( + &self, + tokenSent: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + args: ::RustType, + ) -> alloy_contract::SolCallBuilder< + &P, + handleGatewayMessageWithSlippageArgsCall, + N, + > { + self.call_builder( + &handleGatewayMessageWithSlippageArgsCall { + tokenSent, + amount, + recipient, + args, + }, + ) + } + ///Creates a new call builder for the [`segmentStrategy`] function. + pub fn segmentStrategy( + &self, + ) -> alloy_contract::SolCallBuilder<&P, segmentStrategyCall, N> { + self.call_builder(&segmentStrategyCall) + } + ///Creates a new call builder for the [`solvLSTStrategy`] function. + pub fn solvLSTStrategy( + &self, + ) -> alloy_contract::SolCallBuilder<&P, solvLSTStrategyCall, N> { + self.call_builder(&solvLSTStrategyCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SegmentSolvLSTStrategyInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`TokenOutput`] event. + pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/segment_strategy.rs b/crates/bindings/src/segment_strategy.rs new file mode 100644 index 000000000..b1f1b1157 --- /dev/null +++ b/crates/bindings/src/segment_strategy.rs @@ -0,0 +1,1554 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface SegmentStrategy { + struct StrategySlippageArgs { + uint256 amountOutMin; + } + + event TokenOutput(address tokenReceived, uint256 amountOut); + + constructor(address _seBep20); + + function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; + function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; + function seBep20() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_seBep20", + "type": "address", + "internalType": "contract ISeBep20" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessage", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "message", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessageWithSlippageArgs", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "args", + "type": "tuple", + "internalType": "struct StrategySlippageArgs", + "components": [ + { + "name": "amountOutMin", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "seBep20", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract ISeBep20" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "TokenOutput", + "inputs": [ + { + "name": "tokenReceived", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "amountOut", + "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 SegmentStrategy { + use super::*; + use alloy::sol_types as 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__\xFD[P`@Qa\x0C\xC68\x03\x80a\x0C\xC6\x839\x81\x01`@\x81\x90Ra\0.\x91a\0?V[`\x01`\x01`\xA0\x1B\x03\x16`\x80Ra\0lV[_` \x82\x84\x03\x12\x15a\0OW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0eW__\xFD[\x93\x92PPPV[`\x80Qa\x0C.a\0\x98_9_\x81\x81`H\x01R\x81\x81a\x01#\x01R\x81\x81a\x01\x8D\x01Ra\x02K\x01Ra\x0C._\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0?W_5`\xE0\x1C\x80c\x1B\xF7\xDF{\x14a\0CW\x80cPcL\x0E\x14a\0\x93W\x80c\x7F\x81O5\x14a\0\xA8W[__\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\t\xB4V[a\0\xBBV[\0[a\0\xA6a\0\xB66`\x04a\nvV[a\0\xE5V[_\x81\x80` \x01\x90Q\x81\x01\x90a\0\xD0\x91\x90a\n\xFAV[\x90Pa\0\xDE\x85\x85\x85\x84a\0\xE5V[PPPPPV[a\x01\x07s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xA5V[a\x01Hs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05iV[`@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\x83\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\x91_\x91\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xD6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xFA\x91\x90a\x0B\x1EV[`@Q\x7F#2>\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x88\x90R\x91\x92P_\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\x90c#2>\x03\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02\x91W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xB5\x91\x90a\x0B\x1EV[\x90P\x80\x15a\x03\nW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FCould not mint token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@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\x86\x81\x16`\x04\x83\x01R_\x91\x90\x85\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03wW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x9B\x91\x90a\x0B\x1EV[\x90P\x82\x81\x11a\x03\xECW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[_a\x03\xF7\x84\x83a\x0BbV[\x86Q\x90\x91P\x81\x10\x15a\x04KW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05c\x90\x85\x90\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\x90`\x84\x01[`@\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\x06dV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xDDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x01\x91\x90a\x0B\x1EV[a\x06\x0B\x91\x90a\x0B{V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05c\x90\x85\x90\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\x90`d\x01a\x04\xFFV[_a\x06\xC5\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\x07Z\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07UW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xE3\x91\x90a\x0B\x8EV[a\x07UW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[PPPV[``a\x07h\x84\x84_\x85a\x07rV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xEAW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08NW`@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\x03\x01V[__\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\x08v\x91\x90a\x0B\xADV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB0W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB5V[``\x91P[P\x91P\x91Pa\x08\xC5\x82\x82\x86a\x08\xD0V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xDFWP\x81a\x07kV[\x82Q\x15a\x08\xEFW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\x01\x91\x90a\x0B\xC3V[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\t*W__\xFD[PV[\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}Wa\t}a\t-V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xACWa\t\xACa\t-V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xC7W__\xFD[\x845a\t\xD2\x81a\t\tV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xE9\x81a\t\tV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x04W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x14W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n.Wa\n.a\t-V[a\nA` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x83V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nUW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x8AW__\xFD[\x855a\n\x95\x81a\t\tV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xAC\x81a\t\tV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xDDW__\xFD[Pa\n\xE6a\tZV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x0BW__\xFD[Pa\x0B\x14a\tZV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B.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`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x0BuWa\x0Bua\x0B5V[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0BuWa\x0Bua\x0B5V[_` \x82\x84\x03\x12\x15a\x0B\x9EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07kW__\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\xFE\xA2dipfsX\"\x12 \x96\xEFe\xB7\x9F\r\x80\x90U\x93\x15 \xD9\x88!\x13\xA9\xD5\xB6{=\xE4\xB8guk\xD84\x96\x11p%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\0?W_5`\xE0\x1C\x80c\x1B\xF7\xDF{\x14a\0CW\x80cPcL\x0E\x14a\0\x93W\x80c\x7F\x81O5\x14a\0\xA8W[__\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\t\xB4V[a\0\xBBV[\0[a\0\xA6a\0\xB66`\x04a\nvV[a\0\xE5V[_\x81\x80` \x01\x90Q\x81\x01\x90a\0\xD0\x91\x90a\n\xFAV[\x90Pa\0\xDE\x85\x85\x85\x84a\0\xE5V[PPPPPV[a\x01\x07s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xA5V[a\x01Hs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05iV[`@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\x83\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\x91_\x91\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xD6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xFA\x91\x90a\x0B\x1EV[`@Q\x7F#2>\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x88\x90R\x91\x92P_\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\x90c#2>\x03\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02\x91W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xB5\x91\x90a\x0B\x1EV[\x90P\x80\x15a\x03\nW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FCould not mint token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@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\x86\x81\x16`\x04\x83\x01R_\x91\x90\x85\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03wW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x9B\x91\x90a\x0B\x1EV[\x90P\x82\x81\x11a\x03\xECW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[_a\x03\xF7\x84\x83a\x0BbV[\x86Q\x90\x91P\x81\x10\x15a\x04KW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05c\x90\x85\x90\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\x90`\x84\x01[`@\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\x06dV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xDDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x01\x91\x90a\x0B\x1EV[a\x06\x0B\x91\x90a\x0B{V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05c\x90\x85\x90\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\x90`d\x01a\x04\xFFV[_a\x06\xC5\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\x07Z\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07UW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xE3\x91\x90a\x0B\x8EV[a\x07UW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[PPPV[``a\x07h\x84\x84_\x85a\x07rV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xEAW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08NW`@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\x03\x01V[__\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\x08v\x91\x90a\x0B\xADV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB0W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB5V[``\x91P[P\x91P\x91Pa\x08\xC5\x82\x82\x86a\x08\xD0V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xDFWP\x81a\x07kV[\x82Q\x15a\x08\xEFW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\x01\x91\x90a\x0B\xC3V[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\t*W__\xFD[PV[\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}Wa\t}a\t-V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xACWa\t\xACa\t-V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xC7W__\xFD[\x845a\t\xD2\x81a\t\tV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xE9\x81a\t\tV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x04W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x14W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n.Wa\n.a\t-V[a\nA` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x83V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nUW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x8AW__\xFD[\x855a\n\x95\x81a\t\tV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xAC\x81a\t\tV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xDDW__\xFD[Pa\n\xE6a\tZV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x0BW__\xFD[Pa\x0B\x14a\tZV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B.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`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x0BuWa\x0Bua\x0B5V[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0BuWa\x0Bua\x0B5V[_` \x82\x84\x03\x12\x15a\x0B\x9EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07kW__\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\xFE\xA2dipfsX\"\x12 \x96\xEFe\xB7\x9F\r\x80\x90U\x93\x15 \xD9\x88!\x13\xA9\xD5\xB6{=\xE4\xB8guk\xD84\x96\x11p%dsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct StrategySlippageArgs { uint256 amountOutMin; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct StrategySlippageArgs { + #[allow(missing_docs)] + pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: StrategySlippageArgs) -> Self { + (value.amountOutMin,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for StrategySlippageArgs { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { amountOutMin: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for StrategySlippageArgs { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for StrategySlippageArgs { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for StrategySlippageArgs { + const NAME: &'static str = "StrategySlippageArgs"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "StrategySlippageArgs(uint256 amountOutMin)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) + .0 + .to_vec() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for StrategySlippageArgs { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.amountOutMin, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.amountOutMin, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. +```solidity +event TokenOutput(address tokenReceived, uint256 amountOut); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct TokenOutput { + #[allow(missing_docs)] + pub tokenReceived: alloy::sol_types::private::Address, + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for TokenOutput { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + tokenReceived: data.0, + amountOut: data.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.tokenReceived, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountOut), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 TokenOutput { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&TokenOutput> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(address _seBep20); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _seBep20: alloy::sol_types::private::Address, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._seBep20,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _seBep20: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolConstructor for constructorCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._seBep20, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. +```solidity +function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub message: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ); + #[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, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.message) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + message: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageCall { + 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, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; + const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.message, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. +```solidity +function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub args: ::RustType, + } + ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Address, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.args) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + args: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageWithSlippageArgsReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageWithSlippageArgsReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; + const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.args, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `seBep20()` and selector `0x1bf7df7b`. +```solidity +function seBep20() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct seBep20Call; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`seBep20()`](seBep20Call) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct seBep20Return { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: seBep20Call) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for seBep20Call { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: seBep20Return) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for seBep20Return { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for seBep20Call { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "seBep20()"; + const SELECTOR: [u8; 4] = [27u8, 247u8, 223u8, 123u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: seBep20Return = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: seBep20Return = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`SegmentStrategy`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum SegmentStrategyCalls { + #[allow(missing_docs)] + handleGatewayMessage(handleGatewayMessageCall), + #[allow(missing_docs)] + handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), + #[allow(missing_docs)] + seBep20(seBep20Call), + } + #[automatically_derived] + impl SegmentStrategyCalls { + /// 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]] = &[ + [27u8, 247u8, 223u8, 123u8], + [80u8, 99u8, 76u8, 14u8], + [127u8, 129u8, 79u8, 53u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for SegmentStrategyCalls { + const NAME: &'static str = "SegmentStrategyCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 3usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::handleGatewayMessage(_) => { + ::SELECTOR + } + Self::handleGatewayMessageWithSlippageArgs(_) => { + ::SELECTOR + } + Self::seBep20(_) => ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn seBep20( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(SegmentStrategyCalls::seBep20) + } + seBep20 + }, + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SegmentStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + SegmentStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn seBep20( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentStrategyCalls::seBep20) + } + seBep20 + }, + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + SegmentStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::handleGatewayMessage(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::seBep20(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::handleGatewayMessage(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::seBep20(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + ///Container for all the [`SegmentStrategy`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum SegmentStrategyEvents { + #[allow(missing_docs)] + TokenOutput(TokenOutput), + } + #[automatically_derived] + impl SegmentStrategyEvents { + /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for SegmentStrategyEvents { + const NAME: &'static str = "SegmentStrategyEvents"; + const COUNT: usize = 1usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::TokenOutput) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 SegmentStrategyEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`SegmentStrategy`](self) contract instance. + +See the [wrapper's documentation](`SegmentStrategyInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> SegmentStrategyInstance { + SegmentStrategyInstance::::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: alloy_contract::private::Network, + >( + provider: P, + _seBep20: alloy::sol_types::private::Address, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + SegmentStrategyInstance::::deploy(provider, _seBep20) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + _seBep20: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + SegmentStrategyInstance::::deploy_builder(provider, _seBep20) + } + /**A [`SegmentStrategy`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`SegmentStrategy`](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 SegmentStrategyInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for SegmentStrategyInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("SegmentStrategyInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SegmentStrategyInstance { + /**Creates a new wrapper around an on-chain [`SegmentStrategy`](self) contract instance. + +See the [wrapper's documentation](`SegmentStrategyInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + _seBep20: alloy::sol_types::private::Address, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(provider, _seBep20); + 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, + _seBep20: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { _seBep20 }, + )[..], + ] + .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 SegmentStrategyInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> SegmentStrategyInstance { + SegmentStrategyInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SegmentStrategyInstance { + /// 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( + &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 [`handleGatewayMessage`] function. + pub fn handleGatewayMessage( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + message: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { + self.call_builder( + &handleGatewayMessageCall { + tokenSent, + amountIn, + recipient, + message, + }, + ) + } + ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. + pub fn handleGatewayMessageWithSlippageArgs( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + args: ::RustType, + ) -> alloy_contract::SolCallBuilder< + &P, + handleGatewayMessageWithSlippageArgsCall, + N, + > { + self.call_builder( + &handleGatewayMessageWithSlippageArgsCall { + tokenSent, + amountIn, + recipient, + args, + }, + ) + } + ///Creates a new call builder for the [`seBep20`] function. + pub fn seBep20(&self) -> alloy_contract::SolCallBuilder<&P, seBep20Call, N> { + self.call_builder(&seBep20Call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SegmentStrategyInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`TokenOutput`] event. + pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/segment_strategy_forked.rs b/crates/bindings/src/segment_strategy_forked.rs new file mode 100644 index 000000000..3ec912ab9 --- /dev/null +++ b/crates/bindings/src/segment_strategy_forked.rs @@ -0,0 +1,7991 @@ +///Module containing a contract's types and functions. +/** + +```solidity +library StdInvariant { + struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } + struct FuzzInterface { address addr; string[] artifacts; } + struct FuzzSelector { address addr; bytes4[] selectors; } +} +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod StdInvariant { + use super::*; + use alloy::sol_types as alloy_sol_types; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzArtifactSelector { + #[allow(missing_docs)] + pub artifact: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub selectors: alloy::sol_types::private::Vec< + 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 as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::String, + alloy::sol_types::private::Vec>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzArtifactSelector) -> Self { + (value.artifact, value.selectors) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzArtifactSelector { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + artifact: tuple.0, + selectors: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzArtifactSelector { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.artifact, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.selectors), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzArtifactSelector { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzArtifactSelector { + const NAME: &'static str = "FuzzArtifactSelector"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzArtifactSelector(string artifact,bytes4[] selectors)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.artifact, + ) + .0, + , + > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzArtifactSelector { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.artifact, + ) + + , + > as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.selectors, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.artifact, + out, + ); + , + > as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.selectors, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzInterface { address addr; string[] artifacts; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzInterface { + #[allow(missing_docs)] + pub addr: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub artifacts: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzInterface) -> Self { + (value.addr, value.artifacts) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzInterface { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + addr: tuple.0, + artifacts: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzInterface { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzInterface { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.addr, + ), + as alloy_sol_types::SolType>::tokenize(&self.artifacts), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzInterface { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzInterface { + const NAME: &'static str = "FuzzInterface"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzInterface(address addr,string[] artifacts)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.addr, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzInterface { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.addr, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.artifacts, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.addr, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.artifacts, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzSelector { address addr; bytes4[] selectors; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzSelector { + #[allow(missing_docs)] + pub addr: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub selectors: alloy::sol_types::private::Vec< + 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 as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Vec>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzSelector) -> Self { + (value.addr, value.selectors) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzSelector { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + addr: tuple.0, + selectors: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzSelector { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzSelector { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.addr, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.selectors), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzSelector { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzSelector { + const NAME: &'static str = "FuzzSelector"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzSelector(address addr,bytes4[] selectors)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.addr, + ) + .0, + , + > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzSelector { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.addr, + ) + + , + > as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.selectors, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.addr, + out, + ); + , + > as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.selectors, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. + +See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> StdInvariantInstance { + StdInvariantInstance::::new(address, provider) + } + /**A [`StdInvariant`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`StdInvariant`](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 StdInvariantInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for StdInvariantInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("StdInvariantInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. + +See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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 StdInvariantInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> StdInvariantInstance { + StdInvariantInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} +/** + +Generated by the following Solidity interface... +```solidity +library StdInvariant { + struct FuzzArtifactSelector { + string artifact; + bytes4[] selectors; + } + struct FuzzInterface { + address addr; + string[] artifacts; + } + struct FuzzSelector { + address addr; + bytes4[] selectors; + } +} + +interface SegmentStrategyForked { + event log(string); + event log_address(address); + event log_array(uint256[] val); + event log_array(int256[] val); + event log_array(address[] val); + event log_bytes(bytes); + event log_bytes32(bytes32); + event log_int(int256); + event log_named_address(string key, address val); + event log_named_array(string key, uint256[] val); + event log_named_array(string key, int256[] val); + event log_named_array(string key, address[] val); + event log_named_bytes(string key, bytes val); + event log_named_bytes32(string key, bytes32 val); + event log_named_decimal_int(string key, int256 val, uint256 decimals); + event log_named_decimal_uint(string key, uint256 val, uint256 decimals); + event log_named_int(string key, int256 val); + event log_named_string(string key, string val); + event log_named_uint(string key, uint256 val); + event log_string(string); + event log_uint(uint256); + event logs(bytes); + + function IS_TEST() external view returns (bool); + function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); + function excludeContracts() external view returns (address[] memory excludedContracts_); + function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); + function excludeSenders() external view returns (address[] memory excludedSenders_); + function failed() external view returns (bool); + function setUp() external; + function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; + function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); + function targetArtifacts() external view returns (string[] memory targetedArtifacts_); + function targetContracts() external view returns (address[] memory targetedContracts_); + function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); + function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); + function targetSenders() external view returns (address[] memory targetedSenders_); + function testSegmentStrategy() external; + function token() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "IS_TEST", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeArtifacts", + "inputs": [], + "outputs": [ + { + "name": "excludedArtifacts_", + "type": "string[]", + "internalType": "string[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeContracts", + "inputs": [], + "outputs": [ + { + "name": "excludedContracts_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeSelectors", + "inputs": [], + "outputs": [ + { + "name": "excludedSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzSelector[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeSenders", + "inputs": [], + "outputs": [ + { + "name": "excludedSenders_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "failed", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "setUp", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "simulateForkAndTransfer", + "inputs": [ + { + "name": "forkAtBlock", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "sender", + "type": "address", + "internalType": "address" + }, + { + "name": "receiver", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "targetArtifactSelectors", + "inputs": [], + "outputs": [ + { + "name": "targetedArtifactSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzArtifactSelector[]", + "components": [ + { + "name": "artifact", + "type": "string", + "internalType": "string" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetArtifacts", + "inputs": [], + "outputs": [ + { + "name": "targetedArtifacts_", + "type": "string[]", + "internalType": "string[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetContracts", + "inputs": [], + "outputs": [ + { + "name": "targetedContracts_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetInterfaces", + "inputs": [], + "outputs": [ + { + "name": "targetedInterfaces_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzInterface[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "artifacts", + "type": "string[]", + "internalType": "string[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetSelectors", + "inputs": [], + "outputs": [ + { + "name": "targetedSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzSelector[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetSenders", + "inputs": [], + "outputs": [ + { + "name": "targetedSenders_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "testSegmentStrategy", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "token", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IERC20" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "log", + "inputs": [ + { + "name": "", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_address", + "inputs": [ + { + "name": "", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "uint256[]", + "indexed": false, + "internalType": "uint256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "int256[]", + "indexed": false, + "internalType": "int256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "address[]", + "indexed": false, + "internalType": "address[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_bytes", + "inputs": [ + { + "name": "", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_bytes32", + "inputs": [ + { + "name": "", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_int", + "inputs": [ + { + "name": "", + "type": "int256", + "indexed": false, + "internalType": "int256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_address", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256[]", + "indexed": false, + "internalType": "uint256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256[]", + "indexed": false, + "internalType": "int256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "address[]", + "indexed": false, + "internalType": "address[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_bytes", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_bytes32", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_decimal_int", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256", + "indexed": false, + "internalType": "int256" + }, + { + "name": "decimals", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_decimal_uint", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "decimals", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_int", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256", + "indexed": false, + "internalType": "int256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_string", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_uint", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_string", + "inputs": [ + { + "name": "", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_uint", + "inputs": [ + { + "name": "", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "logs", + "inputs": [ + { + "name": "", + "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 SegmentStrategyForked { + use super::*; + use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15`+W__\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16t\xBB\xA2\xEF\x94]R^<#\x14a\x01=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05\xD0W__\xFD[PZ\xF1\x15\x80\x15a\x05\xE2W=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x06iW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x8D\x91\x90a\x18\x88V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07%W__\xFD[PZ\xF1\x15\x80\x15a\x077W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07\x94W__\xFD[PZ\xF1\x15\x80\x15a\x07\xA6W=__>=_\xFD[PP`@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\x81R`\x01`\x04\x82\x01R_\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x15W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x089\x91\x90a\x18\xAEV[\x90Pa\x08{\x81_`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01\x7FUser has seTokens\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x13\xB9V[`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\tO\x91a\x01\0\x90\x04s\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\x08\xEFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\x13\x91\x90a\x18\xAEV[_`@Q\x80`@\x01`@R\x80`\x17\x81R` \x01\x7FUser has no TBTC tokens\0\0\0\0\0\0\0\0\0\x81RPa\x14>V[`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t\xB2W__\xFD[PZ\xF1\x15\x80\x15a\t\xC4W=__>=_\xFD[PP`@Q\x7F\xDB\0ju\0\0\0\0\0\0\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\x90Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x16\x92Pc\xDB\0ju\x91P`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\n2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\nV\x91\x90a\x18\xAEV[P`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\x0B\x0E\x91a\x01\0\x90\x04s\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\n\xCBW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xEF\x91\x90a\x18\xAEV[_`@Q\x80``\x01`@R\x80`&\x81R` \x01a&\xB5`&\x919a\x13\xB9V[PPPV[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x0Bf\x90a\x187V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\x92\x90a\x187V[\x80\x15a\x0B\xDDW\x80`\x1F\x10a\x0B\xB4Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\xDDV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xC0W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x0CtW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C!W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0B6V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\x0C\xCC\x90a\x187V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C\xF8\x90a\x187V[\x80\x15a\rCW\x80`\x1F\x10a\r\x1AWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rCV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r&W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xAFV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0EBW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\xEFW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\rzV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0FEW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0E\xF2W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0E}V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\x0F\x9D\x90a\x187V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F\xC9\x90a\x187V[\x80\x15a\x10\x14W\x80`\x1F\x10a\x0F\xEBWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x10\x14V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\xF7W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0F\x80V[`\x08T_\x90`\xFF\x16\x15a\x10?WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\xCDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\xF1\x91\x90a\x18\xAEV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\xFEW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x12%\x91\x90\x81\x01\x90a\x18\xF2V[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x12C\x92\x91\x90a\x19\xA6V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x12_W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\x83\x91\x90a\x18\xAEV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12\xFCW__\xFD[PZ\xF1\x15\x80\x15a\x13\x0EW=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x13\x8EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13\xB2\x91\x90a\x18\x88V[PPPPPV[`@Q\x7F\xD9\xA3\xC4\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xD9\xA3\xC4\xD2\x90a\x14\r\x90\x86\x90\x86\x90\x86\x90`\x04\x01a\x19\xC7V[_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x14#W__\xFD[PZ\xFA\x15\x80\x15a\x145W=__>=_\xFD[PPPPPPPV[`@Q\x7F\x88\xB4L\x85\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x88\xB4L\x85\x90a\x14\r\x90\x86\x90\x86\x90\x86\x90`\x04\x01a\x19\xC7V[a\x0C\xC6\x80a\x19\xEF\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x14\xECW\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\x14\xB8V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x16\rW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x15\xF3W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x15\xDD\x84\x86Qa\x14\xF7V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x15\xA3V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x15KV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x16kW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x16+V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x16\rW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x16\xC1`@\x88\x01\x82a\x14\xF7V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x16\xDC\x81\x83a\x16\x19V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16\x9BV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x16\rW`?\x19\x87\x86\x03\x01\x84Ra\x175\x85\x83Qa\x14\xF7V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x17\x19V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x16\rW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x17\xB8`@\x87\x01\x82a\x16\x19V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x17pV[\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\xF1W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x18\tW__\xFD[\x845\x93Pa\x18\x19` \x86\x01a\x17\xCEV[\x92Pa\x18'`@\x86\x01a\x17\xCEV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x18KW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x18\x82W\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x18\x98W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x18\xA7W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x18\xBEW__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x19\x02W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x19\x18W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x19(W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x19BWa\x19Ba\x18\xC5V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x19rWa\x19ra\x18\xC5V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x19\x89W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x19\xB8`@\x83\x01\x85a\x14\xF7V[\x90P\x82` \x83\x01R\x93\x92PPPV[\x83\x81R\x82` \x82\x01R```@\x82\x01R_a\x19\xE5``\x83\x01\x84a\x14\xF7V[\x95\x94PPPPPV\xFE`\xA0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x0C\xC68\x03\x80a\x0C\xC6\x839\x81\x01`@\x81\x90Ra\0.\x91a\0?V[`\x01`\x01`\xA0\x1B\x03\x16`\x80Ra\0lV[_` \x82\x84\x03\x12\x15a\0OW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0eW__\xFD[\x93\x92PPPV[`\x80Qa\x0C.a\0\x98_9_\x81\x81`H\x01R\x81\x81a\x01#\x01R\x81\x81a\x01\x8D\x01Ra\x02K\x01Ra\x0C._\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0?W_5`\xE0\x1C\x80c\x1B\xF7\xDF{\x14a\0CW\x80cPcL\x0E\x14a\0\x93W\x80c\x7F\x81O5\x14a\0\xA8W[__\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\t\xB4V[a\0\xBBV[\0[a\0\xA6a\0\xB66`\x04a\nvV[a\0\xE5V[_\x81\x80` \x01\x90Q\x81\x01\x90a\0\xD0\x91\x90a\n\xFAV[\x90Pa\0\xDE\x85\x85\x85\x84a\0\xE5V[PPPPPV[a\x01\x07s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xA5V[a\x01Hs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05iV[`@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\x83\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\x91_\x91\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xD6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xFA\x91\x90a\x0B\x1EV[`@Q\x7F#2>\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x88\x90R\x91\x92P_\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\x90c#2>\x03\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02\x91W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xB5\x91\x90a\x0B\x1EV[\x90P\x80\x15a\x03\nW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FCould not mint token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@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\x86\x81\x16`\x04\x83\x01R_\x91\x90\x85\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03wW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x9B\x91\x90a\x0B\x1EV[\x90P\x82\x81\x11a\x03\xECW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[_a\x03\xF7\x84\x83a\x0BbV[\x86Q\x90\x91P\x81\x10\x15a\x04KW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05c\x90\x85\x90\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\x90`\x84\x01[`@\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\x06dV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xDDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x01\x91\x90a\x0B\x1EV[a\x06\x0B\x91\x90a\x0B{V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05c\x90\x85\x90\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\x90`d\x01a\x04\xFFV[_a\x06\xC5\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\x07Z\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07UW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xE3\x91\x90a\x0B\x8EV[a\x07UW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[PPPV[``a\x07h\x84\x84_\x85a\x07rV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xEAW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08NW`@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\x03\x01V[__\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\x08v\x91\x90a\x0B\xADV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB0W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB5V[``\x91P[P\x91P\x91Pa\x08\xC5\x82\x82\x86a\x08\xD0V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xDFWP\x81a\x07kV[\x82Q\x15a\x08\xEFW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\x01\x91\x90a\x0B\xC3V[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\t*W__\xFD[PV[\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}Wa\t}a\t-V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xACWa\t\xACa\t-V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xC7W__\xFD[\x845a\t\xD2\x81a\t\tV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xE9\x81a\t\tV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x04W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x14W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n.Wa\n.a\t-V[a\nA` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x83V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nUW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x8AW__\xFD[\x855a\n\x95\x81a\t\tV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xAC\x81a\t\tV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xDDW__\xFD[Pa\n\xE6a\tZV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x0BW__\xFD[Pa\x0B\x14a\tZV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B.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`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x0BuWa\x0Bua\x0B5V[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0BuWa\x0Bua\x0B5V[_` \x82\x84\x03\x12\x15a\x0B\x9EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07kW__\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\xFE\xA2dipfsX\"\x12 \x96\xEFe\xB7\x9F\r\x80\x90U\x93\x15 \xD9\x88!\x13\xA9\xD5\xB6{=\xE4\xB8guk\xD84\x96\x11p%dsolcC\0\x08\x1C\x003User received TBTC tokens after redeem\xA2dipfsX\"\x12 q\xD7\x80\xCD\x85WHNS\xD8Q_\x92\x85i\xF0>\x86\x0C\x0Ee2\xB4\xA9\xDEyK\x97\xF6\x8F\xD5\x86dsolcC\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\0\xFBW_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\x93W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x01\xBBW\x80c\xF9\xCE\x0EZ\x14a\x01\xC3W\x80c\xFAv&\xD4\x14a\x01\xD6W\x80c\xFC\x0CTj\x14a\x01\xE3W__\xFD[\x80c\x91j\x17\xC6\x14a\x01~W\x80c\xB0FO\xDC\x14a\x01\x93W\x80c\xB5P\x8A\xA9\x14a\x01\x9BW\x80c\xBAAO\xA6\x14a\x01\xA3W__\xFD[\x80c?r\x86\xF4\x11a\0\xCEW\x80c?r\x86\xF4\x14a\x01DW\x80cP\x05\xC7V\x14a\x01LW\x80cf\xD9\xA9\xA0\x14a\x01TW\x80c\x85\"l\x81\x14a\x01iW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x1E\xD7\x83\x1C\x14a\x01\tW\x80c*\xDE8\x80\x14a\x01'W\x80c>^<#\x14a\x01=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05\xD0W__\xFD[PZ\xF1\x15\x80\x15a\x05\xE2W=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x06iW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x8D\x91\x90a\x18\x88V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07%W__\xFD[PZ\xF1\x15\x80\x15a\x077W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07\x94W__\xFD[PZ\xF1\x15\x80\x15a\x07\xA6W=__>=_\xFD[PP`@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\x81R`\x01`\x04\x82\x01R_\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x15W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x089\x91\x90a\x18\xAEV[\x90Pa\x08{\x81_`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01\x7FUser has seTokens\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x13\xB9V[`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\tO\x91a\x01\0\x90\x04s\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\x08\xEFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\x13\x91\x90a\x18\xAEV[_`@Q\x80`@\x01`@R\x80`\x17\x81R` \x01\x7FUser has no TBTC tokens\0\0\0\0\0\0\0\0\0\x81RPa\x14>V[`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t\xB2W__\xFD[PZ\xF1\x15\x80\x15a\t\xC4W=__>=_\xFD[PP`@Q\x7F\xDB\0ju\0\0\0\0\0\0\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\x90Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x16\x92Pc\xDB\0ju\x91P`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\n2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\nV\x91\x90a\x18\xAEV[P`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\x0B\x0E\x91a\x01\0\x90\x04s\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\n\xCBW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xEF\x91\x90a\x18\xAEV[_`@Q\x80``\x01`@R\x80`&\x81R` \x01a&\xB5`&\x919a\x13\xB9V[PPPV[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x0Bf\x90a\x187V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\x92\x90a\x187V[\x80\x15a\x0B\xDDW\x80`\x1F\x10a\x0B\xB4Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\xDDV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xC0W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x0CtW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C!W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0B6V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\x0C\xCC\x90a\x187V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C\xF8\x90a\x187V[\x80\x15a\rCW\x80`\x1F\x10a\r\x1AWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rCV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r&W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xAFV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0EBW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\xEFW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\rzV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0FEW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0E\xF2W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0E}V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\x0F\x9D\x90a\x187V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F\xC9\x90a\x187V[\x80\x15a\x10\x14W\x80`\x1F\x10a\x0F\xEBWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x10\x14V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\xF7W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0F\x80V[`\x08T_\x90`\xFF\x16\x15a\x10?WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\xCDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\xF1\x91\x90a\x18\xAEV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\xFEW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x12%\x91\x90\x81\x01\x90a\x18\xF2V[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x12C\x92\x91\x90a\x19\xA6V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x12_W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\x83\x91\x90a\x18\xAEV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12\xFCW__\xFD[PZ\xF1\x15\x80\x15a\x13\x0EW=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x13\x8EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13\xB2\x91\x90a\x18\x88V[PPPPPV[`@Q\x7F\xD9\xA3\xC4\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xD9\xA3\xC4\xD2\x90a\x14\r\x90\x86\x90\x86\x90\x86\x90`\x04\x01a\x19\xC7V[_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x14#W__\xFD[PZ\xFA\x15\x80\x15a\x145W=__>=_\xFD[PPPPPPPV[`@Q\x7F\x88\xB4L\x85\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x88\xB4L\x85\x90a\x14\r\x90\x86\x90\x86\x90\x86\x90`\x04\x01a\x19\xC7V[a\x0C\xC6\x80a\x19\xEF\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x14\xECW\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\x14\xB8V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x16\rW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x15\xF3W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x15\xDD\x84\x86Qa\x14\xF7V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x15\xA3V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x15KV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x16kW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x16+V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x16\rW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x16\xC1`@\x88\x01\x82a\x14\xF7V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x16\xDC\x81\x83a\x16\x19V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16\x9BV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x16\rW`?\x19\x87\x86\x03\x01\x84Ra\x175\x85\x83Qa\x14\xF7V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x17\x19V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x16\rW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x17\xB8`@\x87\x01\x82a\x16\x19V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x17pV[\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\xF1W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x18\tW__\xFD[\x845\x93Pa\x18\x19` \x86\x01a\x17\xCEV[\x92Pa\x18'`@\x86\x01a\x17\xCEV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x18KW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x18\x82W\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x18\x98W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x18\xA7W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x18\xBEW__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x19\x02W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x19\x18W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x19(W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x19BWa\x19Ba\x18\xC5V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x19rWa\x19ra\x18\xC5V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x19\x89W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x19\xB8`@\x83\x01\x85a\x14\xF7V[\x90P\x82` \x83\x01R\x93\x92PPPV[\x83\x81R\x82` \x82\x01R```@\x82\x01R_a\x19\xE5``\x83\x01\x84a\x14\xF7V[\x95\x94PPPPPV\xFE`\xA0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x0C\xC68\x03\x80a\x0C\xC6\x839\x81\x01`@\x81\x90Ra\0.\x91a\0?V[`\x01`\x01`\xA0\x1B\x03\x16`\x80Ra\0lV[_` \x82\x84\x03\x12\x15a\0OW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0eW__\xFD[\x93\x92PPPV[`\x80Qa\x0C.a\0\x98_9_\x81\x81`H\x01R\x81\x81a\x01#\x01R\x81\x81a\x01\x8D\x01Ra\x02K\x01Ra\x0C._\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0?W_5`\xE0\x1C\x80c\x1B\xF7\xDF{\x14a\0CW\x80cPcL\x0E\x14a\0\x93W\x80c\x7F\x81O5\x14a\0\xA8W[__\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\t\xB4V[a\0\xBBV[\0[a\0\xA6a\0\xB66`\x04a\nvV[a\0\xE5V[_\x81\x80` \x01\x90Q\x81\x01\x90a\0\xD0\x91\x90a\n\xFAV[\x90Pa\0\xDE\x85\x85\x85\x84a\0\xE5V[PPPPPV[a\x01\x07s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xA5V[a\x01Hs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05iV[`@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\x83\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\x91_\x91\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xD6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xFA\x91\x90a\x0B\x1EV[`@Q\x7F#2>\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x88\x90R\x91\x92P_\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\x90c#2>\x03\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02\x91W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xB5\x91\x90a\x0B\x1EV[\x90P\x80\x15a\x03\nW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FCould not mint token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@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\x86\x81\x16`\x04\x83\x01R_\x91\x90\x85\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03wW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x9B\x91\x90a\x0B\x1EV[\x90P\x82\x81\x11a\x03\xECW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[_a\x03\xF7\x84\x83a\x0BbV[\x86Q\x90\x91P\x81\x10\x15a\x04KW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05c\x90\x85\x90\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\x90`\x84\x01[`@\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\x06dV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xDDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x01\x91\x90a\x0B\x1EV[a\x06\x0B\x91\x90a\x0B{V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05c\x90\x85\x90\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\x90`d\x01a\x04\xFFV[_a\x06\xC5\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\x07Z\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07UW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xE3\x91\x90a\x0B\x8EV[a\x07UW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[PPPV[``a\x07h\x84\x84_\x85a\x07rV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xEAW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08NW`@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\x03\x01V[__\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\x08v\x91\x90a\x0B\xADV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB0W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB5V[``\x91P[P\x91P\x91Pa\x08\xC5\x82\x82\x86a\x08\xD0V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xDFWP\x81a\x07kV[\x82Q\x15a\x08\xEFW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\x01\x91\x90a\x0B\xC3V[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\t*W__\xFD[PV[\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}Wa\t}a\t-V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xACWa\t\xACa\t-V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xC7W__\xFD[\x845a\t\xD2\x81a\t\tV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xE9\x81a\t\tV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x04W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x14W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n.Wa\n.a\t-V[a\nA` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x83V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nUW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x8AW__\xFD[\x855a\n\x95\x81a\t\tV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xAC\x81a\t\tV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xDDW__\xFD[Pa\n\xE6a\tZV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x0BW__\xFD[Pa\x0B\x14a\tZV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B.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`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x0BuWa\x0Bua\x0B5V[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0BuWa\x0Bua\x0B5V[_` \x82\x84\x03\x12\x15a\x0B\x9EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07kW__\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\xFE\xA2dipfsX\"\x12 \x96\xEFe\xB7\x9F\r\x80\x90U\x93\x15 \xD9\x88!\x13\xA9\xD5\xB6{=\xE4\xB8guk\xD84\x96\x11p%dsolcC\0\x08\x1C\x003User received TBTC tokens after redeem\xA2dipfsX\"\x12 q\xD7\x80\xCD\x85WHNS\xD8Q_\x92\x85i\xF0>\x86\x0C\x0Ee2\xB4\xA9\xDEyK\x97\xF6\x8F\xD5\x86dsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. +```solidity +event log(string); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log { + type DataTuple<'a> = (alloy::sol_types::sol_data::String,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log(string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, + 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, + 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. +```solidity +event log_address(address); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_address { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_address { + type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_address(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, + 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, + 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_address { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_address> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_address) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. +```solidity +event log_array(uint256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_0 { + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_0 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(uint256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, + 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, + 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_0 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_0> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. +```solidity +event log_array(int256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_1 { + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_1 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(int256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, + 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, + 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_1 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_1> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. +```solidity +event log_array(address[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_2 { + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_2 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(address[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, + 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, + 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_2 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_2> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. +```solidity +event log_bytes(bytes); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_bytes { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_bytes { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_bytes(bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, + 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, + 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_bytes { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_bytes> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. +```solidity +event log_bytes32(bytes32); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_bytes32 { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_bytes32 { + type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_bytes32(bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, + 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, + 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_bytes32 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_bytes32> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. +```solidity +event log_int(int256); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_int { + #[allow(missing_docs)] + pub _0: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_int { + type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_int(int256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, + 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, + 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. +```solidity +event log_named_address(string key, address val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_address { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_address { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Address, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_address(string,address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, + 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, + 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_address { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_address> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. +```solidity +event log_named_array(string key, uint256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_0 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_0 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, + 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, + 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_0 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_0> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. +```solidity +event log_named_array(string key, int256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_1 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_1 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,int256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, + 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, + 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_1 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_1> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. +```solidity +event log_named_array(string key, address[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_2 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_2 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,address[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, + 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, + 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_2 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_2> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. +```solidity +event log_named_bytes(string key, bytes val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_bytes { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_bytes { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Bytes, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, + 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, + 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_bytes { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_bytes> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. +```solidity +event log_named_bytes32(string key, bytes32 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_bytes32 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_bytes32 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::FixedBytes<32>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, + 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, + 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_bytes32 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. +```solidity +event log_named_decimal_int(string key, int256 val, uint256 decimals); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_decimal_int { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::I256, + #[allow(missing_docs)] + pub decimals: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_decimal_int { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Int<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, + 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, + 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + key: data.0, + val: data.1, + decimals: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + as alloy_sol_types::SolType>::tokenize(&self.decimals), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_decimal_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. +```solidity +event log_named_decimal_uint(string key, uint256 val, uint256 decimals); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_decimal_uint { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub decimals: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_decimal_uint { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, + 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, + 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + key: data.0, + val: data.1, + decimals: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + as alloy_sol_types::SolType>::tokenize(&self.decimals), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. +```solidity +event log_named_int(string key, int256 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_int { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_int { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Int<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_int(string,int256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, + 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, + 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. +```solidity +event log_named_string(string key, string val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_string { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::String, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_string { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::String, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_string(string,string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, + 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, + 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_string { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_string> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. +```solidity +event log_named_uint(string key, uint256 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_uint { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_uint { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, + 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, + 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. +```solidity +event log_string(string); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_string { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_string { + type DataTuple<'a> = (alloy::sol_types::sol_data::String,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_string(string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, + 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, + 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_string { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_string> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_string) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. +```solidity +event log_uint(uint256); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_uint { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_uint { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_uint(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, + 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, + 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. +```solidity +event logs(bytes); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct logs { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for logs { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "logs(bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, + 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, + 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 logs { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&logs> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &logs) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. +```solidity +function IS_TEST() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IS_TESTCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IS_TESTReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IS_TESTCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IS_TESTCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IS_TESTReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IS_TESTReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for IS_TESTCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "IS_TEST()"; + const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: IS_TESTReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: IS_TESTReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. +```solidity +function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeArtifactsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeArtifactsReturn { + #[allow(missing_docs)] + pub excludedArtifacts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeArtifactsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeArtifactsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeArtifactsReturn) -> Self { + (value.excludedArtifacts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeArtifactsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedArtifacts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeArtifactsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeArtifacts()"; + const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeArtifactsReturn = r.into(); + r.excludedArtifacts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeArtifactsReturn = r.into(); + r.excludedArtifacts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. +```solidity +function excludeContracts() external view returns (address[] memory excludedContracts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeContractsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeContractsReturn { + #[allow(missing_docs)] + pub excludedContracts_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeContractsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeContractsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeContractsReturn) -> Self { + (value.excludedContracts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeContractsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedContracts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeContractsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeContracts()"; + const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeContractsReturn = r.into(); + r.excludedContracts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeContractsReturn = r.into(); + r.excludedContracts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. +```solidity +function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSelectorsReturn { + #[allow(missing_docs)] + pub excludedSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSelectorsReturn) -> Self { + (value.excludedSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeSelectors()"; + const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeSelectorsReturn = r.into(); + r.excludedSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeSelectorsReturn = r.into(); + r.excludedSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. +```solidity +function excludeSenders() external view returns (address[] memory excludedSenders_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSendersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSendersReturn { + #[allow(missing_docs)] + pub excludedSenders_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: excludeSendersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for excludeSendersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSendersReturn) -> Self { + (value.excludedSenders_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSendersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { excludedSenders_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeSendersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeSenders()"; + const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeSendersReturn = r.into(); + r.excludedSenders_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeSendersReturn = r.into(); + r.excludedSenders_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `failed()` and selector `0xba414fa6`. +```solidity +function failed() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct failedCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`failed()`](failedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct failedReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: failedCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for failedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: failedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for failedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for failedCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "failed()"; + const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: failedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: failedReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `setUp()` and selector `0x0a9254e4`. +```solidity +function setUp() external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setUpCall; + ///Container type for the return parameters of the [`setUp()`](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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setUpCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setUpReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setUpReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setUpCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setUpReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setUp()"; + const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setUpReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. +```solidity +function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct simulateForkAndTransferCall { + #[allow(missing_docs)] + pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub sender: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct simulateForkAndTransferReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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::Uint<256>, + ); + #[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::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferCall) -> Self { + (value.forkAtBlock, value.sender, value.receiver, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for simulateForkAndTransferCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + forkAtBlock: tuple.0, + sender: tuple.1, + receiver: tuple.2, + amount: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for simulateForkAndTransferReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl simulateForkAndTransferReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for simulateForkAndTransferCall { + type Parameters<'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::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = simulateForkAndTransferReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; + const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), + ::tokenize( + &self.sender, + ), + ::tokenize( + &self.receiver, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + simulateForkAndTransferReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. +```solidity +function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactSelectorsReturn { + #[allow(missing_docs)] + pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactSelectorsReturn) -> Self { + (value.targetedArtifactSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedArtifactSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetArtifactSelectors()"; + const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetArtifacts()` and selector `0x85226c81`. +```solidity +function targetArtifacts() external view returns (string[] memory targetedArtifacts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactsReturn { + #[allow(missing_docs)] + pub targetedArtifacts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetArtifactsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsReturn) -> Self { + (value.targetedArtifacts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedArtifacts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetArtifactsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetArtifacts()"; + const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetContracts()` and selector `0x3f7286f4`. +```solidity +function targetContracts() external view returns (address[] memory targetedContracts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetContractsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetContractsReturn { + #[allow(missing_docs)] + pub targetedContracts_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetContractsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetContractsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetContractsReturn) -> Self { + (value.targetedContracts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetContractsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedContracts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetContractsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetContracts()"; + const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetContractsReturn = r.into(); + r.targetedContracts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetContractsReturn = r.into(); + r.targetedContracts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. +```solidity +function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetInterfacesCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetInterfacesReturn { + #[allow(missing_docs)] + pub targetedInterfaces_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetInterfacesCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetInterfacesCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetInterfacesReturn) -> Self { + (value.targetedInterfaces_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetInterfacesReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedInterfaces_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetInterfacesCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetInterfaces()"; + const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetSelectors()` and selector `0x916a17c6`. +```solidity +function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSelectorsReturn { + #[allow(missing_docs)] + pub targetedSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetSelectorsReturn) -> Self { + (value.targetedSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetSelectors()"; + const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. +```solidity +function targetSenders() external view returns (address[] memory targetedSenders_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSendersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSendersReturn { + #[allow(missing_docs)] + pub targetedSenders_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSendersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersReturn) -> Self { + (value.targetedSenders_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSendersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { targetedSenders_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetSendersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetSenders()"; + const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetSendersReturn = r.into(); + r.targetedSenders_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetSendersReturn = r.into(); + r.targetedSenders_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `testSegmentStrategy()` and selector `0x5005c756`. +```solidity +function testSegmentStrategy() external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct testSegmentStrategyCall; + ///Container type for the return parameters of the [`testSegmentStrategy()`](testSegmentStrategyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct testSegmentStrategyReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: testSegmentStrategyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for testSegmentStrategyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: testSegmentStrategyReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for testSegmentStrategyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl testSegmentStrategyReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for testSegmentStrategyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = testSegmentStrategyReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "testSegmentStrategy()"; + const SELECTOR: [u8; 4] = [80u8, 5u8, 199u8, 86u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + testSegmentStrategyReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `token()` and selector `0xfc0c546a`. +```solidity +function token() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct tokenCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`token()`](tokenCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct tokenReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for tokenCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for tokenReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for tokenCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "token()"; + const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`SegmentStrategyForked`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum SegmentStrategyForkedCalls { + #[allow(missing_docs)] + IS_TEST(IS_TESTCall), + #[allow(missing_docs)] + excludeArtifacts(excludeArtifactsCall), + #[allow(missing_docs)] + excludeContracts(excludeContractsCall), + #[allow(missing_docs)] + excludeSelectors(excludeSelectorsCall), + #[allow(missing_docs)] + excludeSenders(excludeSendersCall), + #[allow(missing_docs)] + failed(failedCall), + #[allow(missing_docs)] + setUp(setUpCall), + #[allow(missing_docs)] + simulateForkAndTransfer(simulateForkAndTransferCall), + #[allow(missing_docs)] + targetArtifactSelectors(targetArtifactSelectorsCall), + #[allow(missing_docs)] + targetArtifacts(targetArtifactsCall), + #[allow(missing_docs)] + targetContracts(targetContractsCall), + #[allow(missing_docs)] + targetInterfaces(targetInterfacesCall), + #[allow(missing_docs)] + targetSelectors(targetSelectorsCall), + #[allow(missing_docs)] + targetSenders(targetSendersCall), + #[allow(missing_docs)] + testSegmentStrategy(testSegmentStrategyCall), + #[allow(missing_docs)] + token(tokenCall), + } + #[automatically_derived] + impl SegmentStrategyForkedCalls { + /// 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]] = &[ + [10u8, 146u8, 84u8, 228u8], + [30u8, 215u8, 131u8, 28u8], + [42u8, 222u8, 56u8, 128u8], + [62u8, 94u8, 60u8, 35u8], + [63u8, 114u8, 134u8, 244u8], + [80u8, 5u8, 199u8, 86u8], + [102u8, 217u8, 169u8, 160u8], + [133u8, 34u8, 108u8, 129u8], + [145u8, 106u8, 23u8, 198u8], + [176u8, 70u8, 79u8, 220u8], + [181u8, 80u8, 138u8, 169u8], + [186u8, 65u8, 79u8, 166u8], + [226u8, 12u8, 159u8, 113u8], + [249u8, 206u8, 14u8, 90u8], + [250u8, 118u8, 38u8, 212u8], + [252u8, 12u8, 84u8, 106u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for SegmentStrategyForkedCalls { + const NAME: &'static str = "SegmentStrategyForkedCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 16usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::IS_TEST(_) => ::SELECTOR, + Self::excludeArtifacts(_) => { + ::SELECTOR + } + Self::excludeContracts(_) => { + ::SELECTOR + } + Self::excludeSelectors(_) => { + ::SELECTOR + } + Self::excludeSenders(_) => { + ::SELECTOR + } + Self::failed(_) => ::SELECTOR, + Self::setUp(_) => ::SELECTOR, + Self::simulateForkAndTransfer(_) => { + ::SELECTOR + } + Self::targetArtifactSelectors(_) => { + ::SELECTOR + } + Self::targetArtifacts(_) => { + ::SELECTOR + } + Self::targetContracts(_) => { + ::SELECTOR + } + Self::targetInterfaces(_) => { + ::SELECTOR + } + Self::targetSelectors(_) => { + ::SELECTOR + } + Self::targetSenders(_) => { + ::SELECTOR + } + Self::testSegmentStrategy(_) => { + ::SELECTOR + } + Self::token(_) => ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn setUp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(SegmentStrategyForkedCalls::setUp) + } + setUp + }, + { + fn excludeSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SegmentStrategyForkedCalls::excludeSenders) + } + excludeSenders + }, + { + fn targetInterfaces( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SegmentStrategyForkedCalls::targetInterfaces) + } + targetInterfaces + }, + { + fn targetSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SegmentStrategyForkedCalls::targetSenders) + } + targetSenders + }, + { + fn targetContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SegmentStrategyForkedCalls::targetContracts) + } + targetContracts + }, + { + fn testSegmentStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SegmentStrategyForkedCalls::testSegmentStrategy) + } + testSegmentStrategy + }, + { + fn targetArtifactSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SegmentStrategyForkedCalls::targetArtifactSelectors) + } + targetArtifactSelectors + }, + { + fn targetArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SegmentStrategyForkedCalls::targetArtifacts) + } + targetArtifacts + }, + { + fn targetSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SegmentStrategyForkedCalls::targetSelectors) + } + targetSelectors + }, + { + fn excludeSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SegmentStrategyForkedCalls::excludeSelectors) + } + excludeSelectors + }, + { + fn excludeArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SegmentStrategyForkedCalls::excludeArtifacts) + } + excludeArtifacts + }, + { + fn failed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(SegmentStrategyForkedCalls::failed) + } + failed + }, + { + fn excludeContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SegmentStrategyForkedCalls::excludeContracts) + } + excludeContracts + }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SegmentStrategyForkedCalls::simulateForkAndTransfer) + } + simulateForkAndTransfer + }, + { + fn IS_TEST( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(SegmentStrategyForkedCalls::IS_TEST) + } + IS_TEST + }, + { + fn token( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(SegmentStrategyForkedCalls::token) + } + token + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn setUp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentStrategyForkedCalls::setUp) + } + setUp + }, + { + fn excludeSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentStrategyForkedCalls::excludeSenders) + } + excludeSenders + }, + { + fn targetInterfaces( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentStrategyForkedCalls::targetInterfaces) + } + targetInterfaces + }, + { + fn targetSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentStrategyForkedCalls::targetSenders) + } + targetSenders + }, + { + fn targetContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentStrategyForkedCalls::targetContracts) + } + targetContracts + }, + { + fn testSegmentStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentStrategyForkedCalls::testSegmentStrategy) + } + testSegmentStrategy + }, + { + fn targetArtifactSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentStrategyForkedCalls::targetArtifactSelectors) + } + targetArtifactSelectors + }, + { + fn targetArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentStrategyForkedCalls::targetArtifacts) + } + targetArtifacts + }, + { + fn targetSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentStrategyForkedCalls::targetSelectors) + } + targetSelectors + }, + { + fn excludeSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentStrategyForkedCalls::excludeSelectors) + } + excludeSelectors + }, + { + fn excludeArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentStrategyForkedCalls::excludeArtifacts) + } + excludeArtifacts + }, + { + fn failed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentStrategyForkedCalls::failed) + } + failed + }, + { + fn excludeContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentStrategyForkedCalls::excludeContracts) + } + excludeContracts + }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentStrategyForkedCalls::simulateForkAndTransfer) + } + simulateForkAndTransfer + }, + { + fn IS_TEST( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentStrategyForkedCalls::IS_TEST) + } + IS_TEST + }, + { + fn token( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SegmentStrategyForkedCalls::token) + } + token + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::IS_TEST(inner) => { + ::abi_encoded_size(inner) + } + Self::excludeArtifacts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeContracts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeSenders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::failed(inner) => { + ::abi_encoded_size(inner) + } + Self::setUp(inner) => { + ::abi_encoded_size(inner) + } + Self::simulateForkAndTransfer(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetArtifactSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetArtifacts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetContracts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetInterfaces(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetSenders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::testSegmentStrategy(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::token(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::IS_TEST(inner) => { + ::abi_encode_raw(inner, out) + } + Self::excludeArtifacts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeContracts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeSenders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::failed(inner) => { + ::abi_encode_raw(inner, out) + } + Self::setUp(inner) => { + ::abi_encode_raw(inner, out) + } + Self::simulateForkAndTransfer(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetArtifactSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetArtifacts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetContracts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetInterfaces(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetSenders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::testSegmentStrategy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::token(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + ///Container for all the [`SegmentStrategyForked`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum SegmentStrategyForkedEvents { + #[allow(missing_docs)] + log(log), + #[allow(missing_docs)] + log_address(log_address), + #[allow(missing_docs)] + log_array_0(log_array_0), + #[allow(missing_docs)] + log_array_1(log_array_1), + #[allow(missing_docs)] + log_array_2(log_array_2), + #[allow(missing_docs)] + log_bytes(log_bytes), + #[allow(missing_docs)] + log_bytes32(log_bytes32), + #[allow(missing_docs)] + log_int(log_int), + #[allow(missing_docs)] + log_named_address(log_named_address), + #[allow(missing_docs)] + log_named_array_0(log_named_array_0), + #[allow(missing_docs)] + log_named_array_1(log_named_array_1), + #[allow(missing_docs)] + log_named_array_2(log_named_array_2), + #[allow(missing_docs)] + log_named_bytes(log_named_bytes), + #[allow(missing_docs)] + log_named_bytes32(log_named_bytes32), + #[allow(missing_docs)] + log_named_decimal_int(log_named_decimal_int), + #[allow(missing_docs)] + log_named_decimal_uint(log_named_decimal_uint), + #[allow(missing_docs)] + log_named_int(log_named_int), + #[allow(missing_docs)] + log_named_string(log_named_string), + #[allow(missing_docs)] + log_named_uint(log_named_uint), + #[allow(missing_docs)] + log_string(log_string), + #[allow(missing_docs)] + log_uint(log_uint), + #[allow(missing_docs)] + logs(logs), + } + #[automatically_derived] + impl SegmentStrategyForkedEvents { + /// 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]] = &[ + [ + 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, + 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, + 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, + ], + [ + 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, + 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, + 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, + ], + [ + 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, + 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, + 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, + ], + [ + 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, + 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, + 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, + ], + [ + 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, + 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, + 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, + ], + [ + 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, + 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, + 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, + ], + [ + 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, + 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, + 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, + ], + [ + 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, + 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, + 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, + ], + [ + 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, + 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, + 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, + ], + [ + 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, + 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, + 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, + ], + [ + 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, + 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, + 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, + ], + [ + 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, + 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, + 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, + ], + [ + 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, + 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, + 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, + ], + [ + 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, + 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, + 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, + ], + [ + 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, + 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, + 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, + ], + [ + 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, + 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, + 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, + ], + [ + 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, + 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, + 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, + ], + [ + 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, + 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, + 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, + ], + [ + 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, + 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, + 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, + ], + [ + 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, + 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, + 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, + ], + [ + 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, + 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, + 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, + ], + [ + 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, + 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, + 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for SegmentStrategyForkedEvents { + const NAME: &'static str = "SegmentStrategyForkedEvents"; + const COUNT: usize = 22usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_address) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_0) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_1) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_2) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_bytes) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_bytes32) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log_int) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_address) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_0) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_1) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_2) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_bytes) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_bytes32) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_decimal_int) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_decimal_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_int) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_string) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_string) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::logs) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 SegmentStrategyForkedEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::log(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_address(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_0(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_1(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_2(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_bytes(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_address(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_0(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_1(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_2(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_bytes(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_decimal_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_decimal_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_string(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_string(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::logs(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::log(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_address(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_0(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_1(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_2(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_bytes(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_address(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_0(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_1(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_2(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_bytes(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_decimal_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_decimal_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_string(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_string(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::logs(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`SegmentStrategyForked`](self) contract instance. + +See the [wrapper's documentation](`SegmentStrategyForkedInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> SegmentStrategyForkedInstance { + SegmentStrategyForkedInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + SegmentStrategyForkedInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + SegmentStrategyForkedInstance::::deploy_builder(provider) + } + /**A [`SegmentStrategyForked`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`SegmentStrategyForked`](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 SegmentStrategyForkedInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for SegmentStrategyForkedInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("SegmentStrategyForkedInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SegmentStrategyForkedInstance { + /**Creates a new wrapper around an on-chain [`SegmentStrategyForked`](self) contract instance. + +See the [wrapper's documentation](`SegmentStrategyForkedInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 SegmentStrategyForkedInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> SegmentStrategyForkedInstance { + SegmentStrategyForkedInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SegmentStrategyForkedInstance { + /// 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( + &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 [`IS_TEST`] function. + pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { + self.call_builder(&IS_TESTCall) + } + ///Creates a new call builder for the [`excludeArtifacts`] function. + pub fn excludeArtifacts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { + self.call_builder(&excludeArtifactsCall) + } + ///Creates a new call builder for the [`excludeContracts`] function. + pub fn excludeContracts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { + self.call_builder(&excludeContractsCall) + } + ///Creates a new call builder for the [`excludeSelectors`] function. + pub fn excludeSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { + self.call_builder(&excludeSelectorsCall) + } + ///Creates a new call builder for the [`excludeSenders`] function. + pub fn excludeSenders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { + self.call_builder(&excludeSendersCall) + } + ///Creates a new call builder for the [`failed`] function. + pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { + self.call_builder(&failedCall) + } + ///Creates a new call builder for the [`setUp`] function. + pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { + self.call_builder(&setUpCall) + } + ///Creates a new call builder for the [`simulateForkAndTransfer`] function. + pub fn simulateForkAndTransfer( + &self, + forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + sender: alloy::sol_types::private::Address, + receiver: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { + self.call_builder( + &simulateForkAndTransferCall { + forkAtBlock, + sender, + receiver, + amount, + }, + ) + } + ///Creates a new call builder for the [`targetArtifactSelectors`] function. + pub fn targetArtifactSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { + self.call_builder(&targetArtifactSelectorsCall) + } + ///Creates a new call builder for the [`targetArtifacts`] function. + pub fn targetArtifacts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { + self.call_builder(&targetArtifactsCall) + } + ///Creates a new call builder for the [`targetContracts`] function. + pub fn targetContracts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { + self.call_builder(&targetContractsCall) + } + ///Creates a new call builder for the [`targetInterfaces`] function. + pub fn targetInterfaces( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { + self.call_builder(&targetInterfacesCall) + } + ///Creates a new call builder for the [`targetSelectors`] function. + pub fn targetSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { + self.call_builder(&targetSelectorsCall) + } + ///Creates a new call builder for the [`targetSenders`] function. + pub fn targetSenders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { + self.call_builder(&targetSendersCall) + } + ///Creates a new call builder for the [`testSegmentStrategy`] function. + pub fn testSegmentStrategy( + &self, + ) -> alloy_contract::SolCallBuilder<&P, testSegmentStrategyCall, N> { + self.call_builder(&testSegmentStrategyCall) + } + ///Creates a new call builder for the [`token`] function. + pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { + self.call_builder(&tokenCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SegmentStrategyForkedInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`log`] event. + pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_address`] event. + pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_0`] event. + pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_1`] event. + pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_2`] event. + pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_bytes`] event. + pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_bytes32`] event. + pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_int`] event. + pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_address`] event. + pub fn log_named_address_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_address, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_0`] event. + pub fn log_named_array_0_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_0, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_1`] event. + pub fn log_named_array_1_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_1, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_2`] event. + pub fn log_named_array_2_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_2, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_bytes`] event. + pub fn log_named_bytes_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_bytes, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_bytes32`] event. + pub fn log_named_bytes32_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_bytes32, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_decimal_int`] event. + pub fn log_named_decimal_int_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_decimal_uint`] event. + pub fn log_named_decimal_uint_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_int`] event. + pub fn log_named_int_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_string`] event. + pub fn log_named_string_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_string, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_uint`] event. + pub fn log_named_uint_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_string`] event. + pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_uint`] event. + pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`logs`] event. + pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/shoebill_strategy.rs b/crates/bindings/src/shoebill_strategy.rs new file mode 100644 index 000000000..243d6b144 --- /dev/null +++ b/crates/bindings/src/shoebill_strategy.rs @@ -0,0 +1,1554 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface ShoebillStrategy { + struct StrategySlippageArgs { + uint256 amountOutMin; + } + + event TokenOutput(address tokenReceived, uint256 amountOut); + + constructor(address _cErc20); + + function cErc20() external view returns (address); + function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; + function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_cErc20", + "type": "address", + "internalType": "contract ICErc20" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "cErc20", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract ICErc20" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "handleGatewayMessage", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "message", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessageWithSlippageArgs", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "args", + "type": "tuple", + "internalType": "struct StrategySlippageArgs", + "components": [ + { + "name": "amountOutMin", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "event", + "name": "TokenOutput", + "inputs": [ + { + "name": "tokenReceived", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "amountOut", + "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 ShoebillStrategy { + use super::*; + use alloy::sol_types as 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__\xFD[P`@Qa\x0B\xF98\x03\x80a\x0B\xF9\x839\x81\x01`@\x81\x90R`+\x91`;V[`\x01`\x01`\xA0\x1B\x03\x16`\x80R`fV[_` \x82\x84\x03\x12\x15`JW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14`_W__\xFD[\x93\x92PPPV[`\x80Qa\x0Bna\0\x8B_9_\x81\x81`]\x01R\x81\x81a\x01#\x01Ra\x01w\x01Ra\x0Bn_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0?W_5`\xE0\x1C\x80cPcL\x0E\x14a\0CW\x80csBDG\x14a\0XW\x80c\x7F\x81O5\x14a\0\xA8W[__\xFD[a\0Va\0Q6`\x04a\t\x0FV[a\0\xBBV[\0[a\0\x7F\x7F\0\0\0\0\0\0\0\0\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\0Va\0\xB66`\x04a\t\xD1V[a\0\xE5V[_\x81\x80` \x01\x90Q\x81\x01\x90a\0\xD0\x91\x90a\nUV[\x90Pa\0\xDE\x85\x85\x85\x84a\0\xE5V[PPPPPV[a\x01\x07s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x03\xAAV[a\x01Hs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04nV[`@Q\x7F\xA0q-h\0\0\0\0\0\0\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\x7F\0\0\0\0\0\0\0\0\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_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x90c\xA0q-h\x90`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\xD6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xFA\x91\x90a\nyV[\x90P\x80\x15a\x02OW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FCould not mint token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@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\x02\xB9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xDD\x91\x90a\nyV[\x84Q\x90\x91P\x81\x10\x15a\x031W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02FV[a\x03Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x86\x83a\x05iV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04h\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xC4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04\xE2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x06\x91\x90a\nyV[a\x05\x10\x91\x90a\n\x90V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04h\x90\x85\x90\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\x90`d\x01a\x04\x04V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x05\xBF\x90\x84\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\x90`d\x01a\x04\x04V[PPPV[_a\x06%\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\x06\xB5\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x05\xBFW\x80\x80` \x01\x90Q\x81\x01\x90a\x06C\x91\x90a\n\xCEV[a\x05\xBFW`@QbF\x1B\xCD`\xE5\x1B\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\x02FV[``a\x06\xC3\x84\x84_\x85a\x06\xCDV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07EW`@QbF\x1B\xCD`\xE5\x1B\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\x02FV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x07\xA9W`@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\x02FV[__\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\x07\xD1\x91\x90a\n\xEDV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x0BW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x10V[``\x91P[P\x91P\x91Pa\x08 \x82\x82\x86a\x08+V[\x97\x96PPPPPPPV[``\x83\x15a\x08:WP\x81a\x06\xC6V[\x82Q\x15a\x08JW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x02F\x91\x90a\x0B\x03V[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\x08\x85W__\xFD[PV[\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\x08\xD8Wa\x08\xD8a\x08\x88V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\x07Wa\t\x07a\x08\x88V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\"W__\xFD[\x845a\t-\x81a\x08dV[\x93P` \x85\x015\x92P`@\x85\x015a\tD\x81a\x08dV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t_W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\toW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\x89Wa\t\x89a\x08\x88V[a\t\x9C` `\x1F\x19`\x1F\x84\x01\x16\x01a\x08\xDEV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\t\xB0W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\t\xE5W__\xFD[\x855a\t\xF0\x81a\x08dV[\x94P` \x86\x015\x93P`@\x86\x015a\n\x07\x81a\x08dV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n8W__\xFD[Pa\nAa\x08\xB5V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\nfW__\xFD[Pa\noa\x08\xB5V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\n\x89W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\n\xC8W\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[_` \x82\x84\x03\x12\x15a\n\xDEW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x06\xC6W__\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\xFE\xA2dipfsX\"\x12 \x11\xC0\xA5i\xF8\x0BGqCjz\x14\\T\xBC\x88\xC6\r\xF6\xCC\x19\\\x95\xB8\xDB\xC3\xCDP\xA5\xC2\x0E\x86dsolcC\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\0?W_5`\xE0\x1C\x80cPcL\x0E\x14a\0CW\x80csBDG\x14a\0XW\x80c\x7F\x81O5\x14a\0\xA8W[__\xFD[a\0Va\0Q6`\x04a\t\x0FV[a\0\xBBV[\0[a\0\x7F\x7F\0\0\0\0\0\0\0\0\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\0Va\0\xB66`\x04a\t\xD1V[a\0\xE5V[_\x81\x80` \x01\x90Q\x81\x01\x90a\0\xD0\x91\x90a\nUV[\x90Pa\0\xDE\x85\x85\x85\x84a\0\xE5V[PPPPPV[a\x01\x07s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x03\xAAV[a\x01Hs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04nV[`@Q\x7F\xA0q-h\0\0\0\0\0\0\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\x7F\0\0\0\0\0\0\0\0\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_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x90c\xA0q-h\x90`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\xD6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xFA\x91\x90a\nyV[\x90P\x80\x15a\x02OW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FCould not mint token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@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\x02\xB9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xDD\x91\x90a\nyV[\x84Q\x90\x91P\x81\x10\x15a\x031W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02FV[a\x03Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x86\x83a\x05iV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04h\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xC4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04\xE2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x06\x91\x90a\nyV[a\x05\x10\x91\x90a\n\x90V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04h\x90\x85\x90\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\x90`d\x01a\x04\x04V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x05\xBF\x90\x84\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\x90`d\x01a\x04\x04V[PPPV[_a\x06%\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\x06\xB5\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x05\xBFW\x80\x80` \x01\x90Q\x81\x01\x90a\x06C\x91\x90a\n\xCEV[a\x05\xBFW`@QbF\x1B\xCD`\xE5\x1B\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\x02FV[``a\x06\xC3\x84\x84_\x85a\x06\xCDV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07EW`@QbF\x1B\xCD`\xE5\x1B\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\x02FV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x07\xA9W`@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\x02FV[__\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\x07\xD1\x91\x90a\n\xEDV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x0BW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x10V[``\x91P[P\x91P\x91Pa\x08 \x82\x82\x86a\x08+V[\x97\x96PPPPPPPV[``\x83\x15a\x08:WP\x81a\x06\xC6V[\x82Q\x15a\x08JW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x02F\x91\x90a\x0B\x03V[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\x08\x85W__\xFD[PV[\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\x08\xD8Wa\x08\xD8a\x08\x88V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\x07Wa\t\x07a\x08\x88V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\"W__\xFD[\x845a\t-\x81a\x08dV[\x93P` \x85\x015\x92P`@\x85\x015a\tD\x81a\x08dV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t_W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\toW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\x89Wa\t\x89a\x08\x88V[a\t\x9C` `\x1F\x19`\x1F\x84\x01\x16\x01a\x08\xDEV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\t\xB0W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\t\xE5W__\xFD[\x855a\t\xF0\x81a\x08dV[\x94P` \x86\x015\x93P`@\x86\x015a\n\x07\x81a\x08dV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n8W__\xFD[Pa\nAa\x08\xB5V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\nfW__\xFD[Pa\noa\x08\xB5V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\n\x89W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\n\xC8W\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[_` \x82\x84\x03\x12\x15a\n\xDEW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x06\xC6W__\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\xFE\xA2dipfsX\"\x12 \x11\xC0\xA5i\xF8\x0BGqCjz\x14\\T\xBC\x88\xC6\r\xF6\xCC\x19\\\x95\xB8\xDB\xC3\xCDP\xA5\xC2\x0E\x86dsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct StrategySlippageArgs { uint256 amountOutMin; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct StrategySlippageArgs { + #[allow(missing_docs)] + pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: StrategySlippageArgs) -> Self { + (value.amountOutMin,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for StrategySlippageArgs { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { amountOutMin: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for StrategySlippageArgs { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for StrategySlippageArgs { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for StrategySlippageArgs { + const NAME: &'static str = "StrategySlippageArgs"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "StrategySlippageArgs(uint256 amountOutMin)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) + .0 + .to_vec() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for StrategySlippageArgs { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.amountOutMin, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.amountOutMin, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. +```solidity +event TokenOutput(address tokenReceived, uint256 amountOut); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct TokenOutput { + #[allow(missing_docs)] + pub tokenReceived: alloy::sol_types::private::Address, + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for TokenOutput { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + tokenReceived: data.0, + amountOut: data.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.tokenReceived, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountOut), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 TokenOutput { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&TokenOutput> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(address _cErc20); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _cErc20: alloy::sol_types::private::Address, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._cErc20,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _cErc20: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolConstructor for constructorCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Address,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._cErc20, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `cErc20()` and selector `0x73424447`. +```solidity +function cErc20() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct cErc20Call; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`cErc20()`](cErc20Call) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct cErc20Return { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: cErc20Call) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for cErc20Call { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: cErc20Return) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for cErc20Return { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for cErc20Call { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "cErc20()"; + const SELECTOR: [u8; 4] = [115u8, 66u8, 68u8, 71u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: cErc20Return = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: cErc20Return = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. +```solidity +function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub message: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ); + #[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, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.message) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + message: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageCall { + 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, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; + const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.message, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. +```solidity +function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub args: ::RustType, + } + ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Address, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.args) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + args: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageWithSlippageArgsReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageWithSlippageArgsReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; + const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.args, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + ///Container for all the [`ShoebillStrategy`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum ShoebillStrategyCalls { + #[allow(missing_docs)] + cErc20(cErc20Call), + #[allow(missing_docs)] + handleGatewayMessage(handleGatewayMessageCall), + #[allow(missing_docs)] + handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), + } + #[automatically_derived] + impl ShoebillStrategyCalls { + /// 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, 99u8, 76u8, 14u8], + [115u8, 66u8, 68u8, 71u8], + [127u8, 129u8, 79u8, 53u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for ShoebillStrategyCalls { + const NAME: &'static str = "ShoebillStrategyCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 3usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::cErc20(_) => ::SELECTOR, + Self::handleGatewayMessage(_) => { + ::SELECTOR + } + Self::handleGatewayMessageWithSlippageArgs(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ShoebillStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn cErc20( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ShoebillStrategyCalls::cErc20) + } + cErc20 + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + ShoebillStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ShoebillStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn cErc20( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ShoebillStrategyCalls::cErc20) + } + cErc20 + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + ShoebillStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::cErc20(inner) => { + ::abi_encoded_size(inner) + } + Self::handleGatewayMessage(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::cErc20(inner) => { + ::abi_encode_raw(inner, out) + } + Self::handleGatewayMessage(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`ShoebillStrategy`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum ShoebillStrategyEvents { + #[allow(missing_docs)] + TokenOutput(TokenOutput), + } + #[automatically_derived] + impl ShoebillStrategyEvents { + /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for ShoebillStrategyEvents { + const NAME: &'static str = "ShoebillStrategyEvents"; + const COUNT: usize = 1usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::TokenOutput) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 ShoebillStrategyEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`ShoebillStrategy`](self) contract instance. + +See the [wrapper's documentation](`ShoebillStrategyInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> ShoebillStrategyInstance { + ShoebillStrategyInstance::::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: alloy_contract::private::Network, + >( + provider: P, + _cErc20: alloy::sol_types::private::Address, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + ShoebillStrategyInstance::::deploy(provider, _cErc20) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + _cErc20: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + ShoebillStrategyInstance::::deploy_builder(provider, _cErc20) + } + /**A [`ShoebillStrategy`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`ShoebillStrategy`](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 ShoebillStrategyInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for ShoebillStrategyInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("ShoebillStrategyInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ShoebillStrategyInstance { + /**Creates a new wrapper around an on-chain [`ShoebillStrategy`](self) contract instance. + +See the [wrapper's documentation](`ShoebillStrategyInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + _cErc20: alloy::sol_types::private::Address, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(provider, _cErc20); + 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, + _cErc20: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { _cErc20 }, + )[..], + ] + .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 ShoebillStrategyInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> ShoebillStrategyInstance { + ShoebillStrategyInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ShoebillStrategyInstance { + /// 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( + &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 [`cErc20`] function. + pub fn cErc20(&self) -> alloy_contract::SolCallBuilder<&P, cErc20Call, N> { + self.call_builder(&cErc20Call) + } + ///Creates a new call builder for the [`handleGatewayMessage`] function. + pub fn handleGatewayMessage( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + message: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { + self.call_builder( + &handleGatewayMessageCall { + tokenSent, + amountIn, + recipient, + message, + }, + ) + } + ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. + pub fn handleGatewayMessageWithSlippageArgs( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + args: ::RustType, + ) -> alloy_contract::SolCallBuilder< + &P, + handleGatewayMessageWithSlippageArgsCall, + N, + > { + self.call_builder( + &handleGatewayMessageWithSlippageArgsCall { + tokenSent, + amountIn, + recipient, + args, + }, + ) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ShoebillStrategyInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`TokenOutput`] event. + pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/shoebill_tbtc_strategy_forked.rs b/crates/bindings/src/shoebill_tbtc_strategy_forked.rs new file mode 100644 index 000000000..4b244234d --- /dev/null +++ b/crates/bindings/src/shoebill_tbtc_strategy_forked.rs @@ -0,0 +1,8006 @@ +///Module containing a contract's types and functions. +/** + +```solidity +library StdInvariant { + struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } + struct FuzzInterface { address addr; string[] artifacts; } + struct FuzzSelector { address addr; bytes4[] selectors; } +} +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod StdInvariant { + use super::*; + use alloy::sol_types as alloy_sol_types; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzArtifactSelector { + #[allow(missing_docs)] + pub artifact: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub selectors: alloy::sol_types::private::Vec< + 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 as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::String, + alloy::sol_types::private::Vec>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzArtifactSelector) -> Self { + (value.artifact, value.selectors) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzArtifactSelector { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + artifact: tuple.0, + selectors: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzArtifactSelector { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.artifact, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.selectors), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzArtifactSelector { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzArtifactSelector { + const NAME: &'static str = "FuzzArtifactSelector"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzArtifactSelector(string artifact,bytes4[] selectors)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.artifact, + ) + .0, + , + > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzArtifactSelector { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.artifact, + ) + + , + > as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.selectors, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.artifact, + out, + ); + , + > as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.selectors, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzInterface { address addr; string[] artifacts; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzInterface { + #[allow(missing_docs)] + pub addr: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub artifacts: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzInterface) -> Self { + (value.addr, value.artifacts) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzInterface { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + addr: tuple.0, + artifacts: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzInterface { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzInterface { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.addr, + ), + as alloy_sol_types::SolType>::tokenize(&self.artifacts), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzInterface { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzInterface { + const NAME: &'static str = "FuzzInterface"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzInterface(address addr,string[] artifacts)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.addr, + ) + .0, + as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzInterface { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.addr, + ) + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.artifacts, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.addr, + out, + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.artifacts, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct FuzzSelector { address addr; bytes4[] selectors; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct FuzzSelector { + #[allow(missing_docs)] + pub addr: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub selectors: alloy::sol_types::private::Vec< + 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 as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Array>, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Vec>, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: FuzzSelector) -> Self { + (value.addr, value.selectors) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for FuzzSelector { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + addr: tuple.0, + selectors: tuple.1, + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for FuzzSelector { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for FuzzSelector { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + ::tokenize( + &self.addr, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.selectors), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for FuzzSelector { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for FuzzSelector { + const NAME: &'static str = "FuzzSelector"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "FuzzSelector(address addr,bytes4[] selectors)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + [ + ::eip712_data_word( + &self.addr, + ) + .0, + , + > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) + .0, + ] + .concat() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for FuzzSelector { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + ::topic_preimage_length( + &rust.addr, + ) + + , + > as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.selectors, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.addr, + out, + ); + , + > as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.selectors, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. + +See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> StdInvariantInstance { + StdInvariantInstance::::new(address, provider) + } + /**A [`StdInvariant`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`StdInvariant`](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 StdInvariantInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for StdInvariantInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("StdInvariantInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. + +See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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 StdInvariantInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> StdInvariantInstance { + StdInvariantInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdInvariantInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} +/** + +Generated by the following Solidity interface... +```solidity +library StdInvariant { + struct FuzzArtifactSelector { + string artifact; + bytes4[] selectors; + } + struct FuzzInterface { + address addr; + string[] artifacts; + } + struct FuzzSelector { + address addr; + bytes4[] selectors; + } +} + +interface ShoebillTBTCStrategyForked { + event log(string); + event log_address(address); + event log_array(uint256[] val); + event log_array(int256[] val); + event log_array(address[] val); + event log_bytes(bytes); + event log_bytes32(bytes32); + event log_int(int256); + event log_named_address(string key, address val); + event log_named_array(string key, uint256[] val); + event log_named_array(string key, int256[] val); + event log_named_array(string key, address[] val); + event log_named_bytes(string key, bytes val); + event log_named_bytes32(string key, bytes32 val); + event log_named_decimal_int(string key, int256 val, uint256 decimals); + event log_named_decimal_uint(string key, uint256 val, uint256 decimals); + event log_named_int(string key, int256 val); + event log_named_string(string key, string val); + event log_named_uint(string key, uint256 val); + event log_string(string); + event log_uint(uint256); + event logs(bytes); + + function IS_TEST() external view returns (bool); + function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); + function excludeContracts() external view returns (address[] memory excludedContracts_); + function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); + function excludeSenders() external view returns (address[] memory excludedSenders_); + function failed() external view returns (bool); + function setUp() external; + function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; + function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); + function targetArtifacts() external view returns (string[] memory targetedArtifacts_); + function targetContracts() external view returns (address[] memory targetedContracts_); + function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); + function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); + function targetSenders() external view returns (address[] memory targetedSenders_); + function testShoebillStrategy() external; + function token() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "IS_TEST", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeArtifacts", + "inputs": [], + "outputs": [ + { + "name": "excludedArtifacts_", + "type": "string[]", + "internalType": "string[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeContracts", + "inputs": [], + "outputs": [ + { + "name": "excludedContracts_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeSelectors", + "inputs": [], + "outputs": [ + { + "name": "excludedSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzSelector[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "excludeSenders", + "inputs": [], + "outputs": [ + { + "name": "excludedSenders_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "failed", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "setUp", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "simulateForkAndTransfer", + "inputs": [ + { + "name": "forkAtBlock", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "sender", + "type": "address", + "internalType": "address" + }, + { + "name": "receiver", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "targetArtifactSelectors", + "inputs": [], + "outputs": [ + { + "name": "targetedArtifactSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzArtifactSelector[]", + "components": [ + { + "name": "artifact", + "type": "string", + "internalType": "string" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetArtifacts", + "inputs": [], + "outputs": [ + { + "name": "targetedArtifacts_", + "type": "string[]", + "internalType": "string[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetContracts", + "inputs": [], + "outputs": [ + { + "name": "targetedContracts_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetInterfaces", + "inputs": [], + "outputs": [ + { + "name": "targetedInterfaces_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzInterface[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "artifacts", + "type": "string[]", + "internalType": "string[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetSelectors", + "inputs": [], + "outputs": [ + { + "name": "targetedSelectors_", + "type": "tuple[]", + "internalType": "struct StdInvariant.FuzzSelector[]", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "selectors", + "type": "bytes4[]", + "internalType": "bytes4[]" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "targetSenders", + "inputs": [], + "outputs": [ + { + "name": "targetedSenders_", + "type": "address[]", + "internalType": "address[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "testShoebillStrategy", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "token", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IERC20" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "log", + "inputs": [ + { + "name": "", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_address", + "inputs": [ + { + "name": "", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "uint256[]", + "indexed": false, + "internalType": "uint256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "int256[]", + "indexed": false, + "internalType": "int256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_array", + "inputs": [ + { + "name": "val", + "type": "address[]", + "indexed": false, + "internalType": "address[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_bytes", + "inputs": [ + { + "name": "", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_bytes32", + "inputs": [ + { + "name": "", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_int", + "inputs": [ + { + "name": "", + "type": "int256", + "indexed": false, + "internalType": "int256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_address", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256[]", + "indexed": false, + "internalType": "uint256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256[]", + "indexed": false, + "internalType": "int256[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_array", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "address[]", + "indexed": false, + "internalType": "address[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_bytes", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_bytes32", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_decimal_int", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256", + "indexed": false, + "internalType": "int256" + }, + { + "name": "decimals", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_decimal_uint", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "decimals", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_int", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256", + "indexed": false, + "internalType": "int256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_string", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_uint", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_string", + "inputs": [ + { + "name": "", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_uint", + "inputs": [ + { + "name": "", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "logs", + "inputs": [ + { + "name": "", + "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 ShoebillTBTCStrategyForked { + use super::*; + use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15`+W__\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16t\xBB\xA2\xEF\x94]R^<#\x14a\x01V[`@Qa\x01\x1E\x91\x90a\x14/V[a\x01\x07a\x08AV[a\x01~a\x0B\x95V[a\x01ia\x0C\x98V[a\x01\xABa\rcV[`@Q\x90\x15\x15\x81R` \x01a\x01\x1EV[a\x01\x11a\x0E3V[a\x01\x07a\x01\xD16`\x04a\x14\xDBV[a\x0E\x9EV[`\x1FTa\x01\xAB\x90`\xFF\x16\x81V[`\x1FTa\x02\x08\x90a\x01\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[`@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\x1EV[a\x02lbU\x8F\x18s\xA7\x9A5k\x01\xEF\x80[0\x89\xB4\xFEgD{\x96\xC7\xE6\xDDLs\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Eg\r\xE0\xB6\xB3\xA7d\0\0a\x0E\x9EV[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\x04W\x83\x82\x90_R` _ \x01\x80Ta\x03y\x90a\x15\x1CV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xA5\x90a\x15\x1CV[\x80\x15a\x03\xF0W\x80`\x1F\x10a\x03\xC7Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xF0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xD3W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03\\V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xFEV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6WPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x05M\x90a\x15\x1CV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05y\x90a\x15\x1CV[\x80\x15a\x05\xC4W\x80`\x1F\x10a\x05\x9BWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05\xC4V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05\xA7W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06[W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x06\x08W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05\x1DV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\x06\xB3\x90a\x15\x1CV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06\xDF\x90a\x15\x1CV[\x80\x15a\x07*W\x80`\x1F\x10a\x07\x01Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07*V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\rW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x06\x96V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x08)W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x07\xD6W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07aV[_s)%\xDF\x9E\xB2\t+S\xB0j\x065:rI\xAF:\x8B\x13\x9E\x90P_\x81`@Qa\x08g\x90a\x11wV[s\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_\xF0\x80\x15\x80\x15a\x08\x9DW=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t\x17W__\xFD[PZ\xF1\x15\x80\x15a\t)W=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\t\xB0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\xD4\x91\x90a\x15mV[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\nlW__\xFD[PZ\xF1\x15\x80\x15a\n~W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\n\xDBW__\xFD[PZ\xF1\x15\x80\x15a\n\xEDW=__>=_\xFD[PP`@Q\x7F:\xF9\xE6i\0\0\0\0\0\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`\x04\x82\x01Ra\x0B\x91\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x91Pc:\xF9\xE6i\x90`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0B_W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\x83\x91\x90a\x15\x93V[g\r\xE0\xB6\xB3\xA5\xD3e\xF2a\x10\xF4V[PPV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\x80W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C-W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0B\xB8V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\x0C\xD8\x90a\x15\x1CV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\x04\x90a\x15\x1CV[\x80\x15a\rOW\x80`\x1F\x10a\r&Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rOV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r2W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xBBV[`\x08T_\x90`\xFF\x16\x15a\rzWP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E,\x91\x90a\x15\x93V[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F9W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x0F`\x91\x90\x81\x01\x90a\x15\xD7V[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0F~\x92\x91\x90a\x16\x8BV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0F\x9AW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xBE\x91\x90a\x15\x93V[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x107W__\xFD[PZ\xF1\x15\x80\x15a\x10IW=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10\xC9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\xED\x91\x90a\x15mV[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x11]W__\xFD[PZ\xFA\x15\x80\x15a\x11oW=__>=_\xFD[PPPPPPV[a\x0B\xF9\x80a\x16\xAD\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x11\xD1W\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\x11\x9DV[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x12\xF2W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x12\xD8W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x12\xC2\x84\x86Qa\x11\xDCV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x12\x88V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x120V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x13PW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x13\x10V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x12\xF2W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x13\xA6`@\x88\x01\x82a\x11\xDCV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x13\xC1\x81\x83a\x12\xFEV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x13\x80V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x12\xF2W`?\x19\x87\x86\x03\x01\x84Ra\x14\x1A\x85\x83Qa\x11\xDCV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x13\xFEV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x12\xF2W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x14\x9D`@\x87\x01\x82a\x12\xFEV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14UV[\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\xD6W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x14\xEEW__\xFD[\x845\x93Pa\x14\xFE` \x86\x01a\x14\xB3V[\x92Pa\x15\x0C`@\x86\x01a\x14\xB3V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x150W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x15gW\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x15}W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x15\x8CW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x15\xA3W__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x15\xE7W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x15\xFDW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x16\rW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16'Wa\x16'a\x15\xAAV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x16WWa\x16Wa\x15\xAAV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x16nW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x16\x9D`@\x83\x01\x85a\x11\xDCV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xA0`@R4\x80\x15`\x0EW__\xFD[P`@Qa\x0B\xF98\x03\x80a\x0B\xF9\x839\x81\x01`@\x81\x90R`+\x91`;V[`\x01`\x01`\xA0\x1B\x03\x16`\x80R`fV[_` \x82\x84\x03\x12\x15`JW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14`_W__\xFD[\x93\x92PPPV[`\x80Qa\x0Bna\0\x8B_9_\x81\x81`]\x01R\x81\x81a\x01#\x01Ra\x01w\x01Ra\x0Bn_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0?W_5`\xE0\x1C\x80cPcL\x0E\x14a\0CW\x80csBDG\x14a\0XW\x80c\x7F\x81O5\x14a\0\xA8W[__\xFD[a\0Va\0Q6`\x04a\t\x0FV[a\0\xBBV[\0[a\0\x7F\x7F\0\0\0\0\0\0\0\0\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\0Va\0\xB66`\x04a\t\xD1V[a\0\xE5V[_\x81\x80` \x01\x90Q\x81\x01\x90a\0\xD0\x91\x90a\nUV[\x90Pa\0\xDE\x85\x85\x85\x84a\0\xE5V[PPPPPV[a\x01\x07s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x03\xAAV[a\x01Hs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04nV[`@Q\x7F\xA0q-h\0\0\0\0\0\0\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\x7F\0\0\0\0\0\0\0\0\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_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x90c\xA0q-h\x90`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\xD6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xFA\x91\x90a\nyV[\x90P\x80\x15a\x02OW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FCould not mint token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@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\x02\xB9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xDD\x91\x90a\nyV[\x84Q\x90\x91P\x81\x10\x15a\x031W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02FV[a\x03Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x86\x83a\x05iV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04h\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xC4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04\xE2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x06\x91\x90a\nyV[a\x05\x10\x91\x90a\n\x90V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04h\x90\x85\x90\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\x90`d\x01a\x04\x04V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x05\xBF\x90\x84\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\x90`d\x01a\x04\x04V[PPPV[_a\x06%\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\x06\xB5\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x05\xBFW\x80\x80` \x01\x90Q\x81\x01\x90a\x06C\x91\x90a\n\xCEV[a\x05\xBFW`@QbF\x1B\xCD`\xE5\x1B\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\x02FV[``a\x06\xC3\x84\x84_\x85a\x06\xCDV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07EW`@QbF\x1B\xCD`\xE5\x1B\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\x02FV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x07\xA9W`@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\x02FV[__\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\x07\xD1\x91\x90a\n\xEDV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x0BW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x10V[``\x91P[P\x91P\x91Pa\x08 \x82\x82\x86a\x08+V[\x97\x96PPPPPPPV[``\x83\x15a\x08:WP\x81a\x06\xC6V[\x82Q\x15a\x08JW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x02F\x91\x90a\x0B\x03V[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\x08\x85W__\xFD[PV[\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\x08\xD8Wa\x08\xD8a\x08\x88V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\x07Wa\t\x07a\x08\x88V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\"W__\xFD[\x845a\t-\x81a\x08dV[\x93P` \x85\x015\x92P`@\x85\x015a\tD\x81a\x08dV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t_W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\toW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\x89Wa\t\x89a\x08\x88V[a\t\x9C` `\x1F\x19`\x1F\x84\x01\x16\x01a\x08\xDEV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\t\xB0W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\t\xE5W__\xFD[\x855a\t\xF0\x81a\x08dV[\x94P` \x86\x015\x93P`@\x86\x015a\n\x07\x81a\x08dV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n8W__\xFD[Pa\nAa\x08\xB5V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\nfW__\xFD[Pa\noa\x08\xB5V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\n\x89W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\n\xC8W\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[_` \x82\x84\x03\x12\x15a\n\xDEW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x06\xC6W__\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\xFE\xA2dipfsX\"\x12 \x11\xC0\xA5i\xF8\x0BGqCjz\x14\\T\xBC\x88\xC6\r\xF6\xCC\x19\\\x95\xB8\xDB\xC3\xCDP\xA5\xC2\x0E\x86dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 \x13 s\xC9\xD6\x90\x10\xEC\xF0\xF9\xD1\xE2\xC7^<#\x14a\x01V[`@Qa\x01\x1E\x91\x90a\x14/V[a\x01\x07a\x08AV[a\x01~a\x0B\x95V[a\x01ia\x0C\x98V[a\x01\xABa\rcV[`@Q\x90\x15\x15\x81R` \x01a\x01\x1EV[a\x01\x11a\x0E3V[a\x01\x07a\x01\xD16`\x04a\x14\xDBV[a\x0E\x9EV[`\x1FTa\x01\xAB\x90`\xFF\x16\x81V[`\x1FTa\x02\x08\x90a\x01\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[`@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\x1EV[a\x02lbU\x8F\x18s\xA7\x9A5k\x01\xEF\x80[0\x89\xB4\xFEgD{\x96\xC7\xE6\xDDLs\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Eg\r\xE0\xB6\xB3\xA7d\0\0a\x0E\x9EV[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\x04W\x83\x82\x90_R` _ \x01\x80Ta\x03y\x90a\x15\x1CV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xA5\x90a\x15\x1CV[\x80\x15a\x03\xF0W\x80`\x1F\x10a\x03\xC7Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xF0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xD3W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03\\V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xFEV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6WPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x05M\x90a\x15\x1CV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05y\x90a\x15\x1CV[\x80\x15a\x05\xC4W\x80`\x1F\x10a\x05\x9BWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05\xC4V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05\xA7W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06[W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x06\x08W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05\x1DV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\x06\xB3\x90a\x15\x1CV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06\xDF\x90a\x15\x1CV[\x80\x15a\x07*W\x80`\x1F\x10a\x07\x01Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07*V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\rW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x06\x96V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x08)W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x07\xD6W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07aV[_s)%\xDF\x9E\xB2\t+S\xB0j\x065:rI\xAF:\x8B\x13\x9E\x90P_\x81`@Qa\x08g\x90a\x11wV[s\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_\xF0\x80\x15\x80\x15a\x08\x9DW=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t\x17W__\xFD[PZ\xF1\x15\x80\x15a\t)W=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\t\xB0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\xD4\x91\x90a\x15mV[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\nlW__\xFD[PZ\xF1\x15\x80\x15a\n~W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\n\xDBW__\xFD[PZ\xF1\x15\x80\x15a\n\xEDW=__>=_\xFD[PP`@Q\x7F:\xF9\xE6i\0\0\0\0\0\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`\x04\x82\x01Ra\x0B\x91\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x91Pc:\xF9\xE6i\x90`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0B_W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\x83\x91\x90a\x15\x93V[g\r\xE0\xB6\xB3\xA5\xD3e\xF2a\x10\xF4V[PPV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\x80W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C-W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0B\xB8V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\x0C\xD8\x90a\x15\x1CV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\x04\x90a\x15\x1CV[\x80\x15a\rOW\x80`\x1F\x10a\r&Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rOV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r2W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xBBV[`\x08T_\x90`\xFF\x16\x15a\rzWP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E,\x91\x90a\x15\x93V[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F9W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x0F`\x91\x90\x81\x01\x90a\x15\xD7V[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0F~\x92\x91\x90a\x16\x8BV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0F\x9AW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xBE\x91\x90a\x15\x93V[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x107W__\xFD[PZ\xF1\x15\x80\x15a\x10IW=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10\xC9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\xED\x91\x90a\x15mV[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x11]W__\xFD[PZ\xFA\x15\x80\x15a\x11oW=__>=_\xFD[PPPPPPV[a\x0B\xF9\x80a\x16\xAD\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x11\xD1W\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\x11\x9DV[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x12\xF2W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x12\xD8W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x12\xC2\x84\x86Qa\x11\xDCV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x12\x88V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x120V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x13PW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x13\x10V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x12\xF2W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x13\xA6`@\x88\x01\x82a\x11\xDCV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x13\xC1\x81\x83a\x12\xFEV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x13\x80V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x12\xF2W`?\x19\x87\x86\x03\x01\x84Ra\x14\x1A\x85\x83Qa\x11\xDCV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x13\xFEV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x12\xF2W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x14\x9D`@\x87\x01\x82a\x12\xFEV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14UV[\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\xD6W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x14\xEEW__\xFD[\x845\x93Pa\x14\xFE` \x86\x01a\x14\xB3V[\x92Pa\x15\x0C`@\x86\x01a\x14\xB3V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x150W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x15gW\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x15}W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x15\x8CW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x15\xA3W__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x15\xE7W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x15\xFDW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x16\rW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16'Wa\x16'a\x15\xAAV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x16WWa\x16Wa\x15\xAAV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x16nW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x16\x9D`@\x83\x01\x85a\x11\xDCV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xA0`@R4\x80\x15`\x0EW__\xFD[P`@Qa\x0B\xF98\x03\x80a\x0B\xF9\x839\x81\x01`@\x81\x90R`+\x91`;V[`\x01`\x01`\xA0\x1B\x03\x16`\x80R`fV[_` \x82\x84\x03\x12\x15`JW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14`_W__\xFD[\x93\x92PPPV[`\x80Qa\x0Bna\0\x8B_9_\x81\x81`]\x01R\x81\x81a\x01#\x01Ra\x01w\x01Ra\x0Bn_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0?W_5`\xE0\x1C\x80cPcL\x0E\x14a\0CW\x80csBDG\x14a\0XW\x80c\x7F\x81O5\x14a\0\xA8W[__\xFD[a\0Va\0Q6`\x04a\t\x0FV[a\0\xBBV[\0[a\0\x7F\x7F\0\0\0\0\0\0\0\0\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\0Va\0\xB66`\x04a\t\xD1V[a\0\xE5V[_\x81\x80` \x01\x90Q\x81\x01\x90a\0\xD0\x91\x90a\nUV[\x90Pa\0\xDE\x85\x85\x85\x84a\0\xE5V[PPPPPV[a\x01\x07s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x03\xAAV[a\x01Hs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04nV[`@Q\x7F\xA0q-h\0\0\0\0\0\0\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\x7F\0\0\0\0\0\0\0\0\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_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x90c\xA0q-h\x90`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\xD6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xFA\x91\x90a\nyV[\x90P\x80\x15a\x02OW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FCould not mint token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@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\x02\xB9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xDD\x91\x90a\nyV[\x84Q\x90\x91P\x81\x10\x15a\x031W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02FV[a\x03Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x86\x83a\x05iV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04h\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xC4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04\xE2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x06\x91\x90a\nyV[a\x05\x10\x91\x90a\n\x90V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04h\x90\x85\x90\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\x90`d\x01a\x04\x04V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x05\xBF\x90\x84\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\x90`d\x01a\x04\x04V[PPPV[_a\x06%\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\x06\xB5\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x05\xBFW\x80\x80` \x01\x90Q\x81\x01\x90a\x06C\x91\x90a\n\xCEV[a\x05\xBFW`@QbF\x1B\xCD`\xE5\x1B\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\x02FV[``a\x06\xC3\x84\x84_\x85a\x06\xCDV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07EW`@QbF\x1B\xCD`\xE5\x1B\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\x02FV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x07\xA9W`@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\x02FV[__\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\x07\xD1\x91\x90a\n\xEDV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x0BW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x10V[``\x91P[P\x91P\x91Pa\x08 \x82\x82\x86a\x08+V[\x97\x96PPPPPPPV[``\x83\x15a\x08:WP\x81a\x06\xC6V[\x82Q\x15a\x08JW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x02F\x91\x90a\x0B\x03V[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\x08\x85W__\xFD[PV[\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\x08\xD8Wa\x08\xD8a\x08\x88V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\x07Wa\t\x07a\x08\x88V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\"W__\xFD[\x845a\t-\x81a\x08dV[\x93P` \x85\x015\x92P`@\x85\x015a\tD\x81a\x08dV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t_W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\toW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\x89Wa\t\x89a\x08\x88V[a\t\x9C` `\x1F\x19`\x1F\x84\x01\x16\x01a\x08\xDEV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\t\xB0W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\t\xE5W__\xFD[\x855a\t\xF0\x81a\x08dV[\x94P` \x86\x015\x93P`@\x86\x015a\n\x07\x81a\x08dV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n8W__\xFD[Pa\nAa\x08\xB5V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\nfW__\xFD[Pa\noa\x08\xB5V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\n\x89W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\n\xC8W\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[_` \x82\x84\x03\x12\x15a\n\xDEW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x06\xC6W__\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\xFE\xA2dipfsX\"\x12 \x11\xC0\xA5i\xF8\x0BGqCjz\x14\\T\xBC\x88\xC6\r\xF6\xCC\x19\\\x95\xB8\xDB\xC3\xCDP\xA5\xC2\x0E\x86dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 \x13 s\xC9\xD6\x90\x10\xEC\xF0\xF9\xD1\xE2\xC7 = (alloy::sol_types::sol_data::String,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log(string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, + 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, + 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. +```solidity +event log_address(address); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_address { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_address { + type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_address(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, + 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, + 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_address { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_address> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_address) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. +```solidity +event log_array(uint256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_0 { + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_0 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(uint256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, + 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, + 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_0 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_0> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. +```solidity +event log_array(int256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_1 { + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_1 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(int256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, + 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, + 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_1 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_1> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. +```solidity +event log_array(address[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_array_2 { + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_array_2 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_array(address[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, + 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, + 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { val: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_array_2 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_array_2> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. +```solidity +event log_bytes(bytes); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_bytes { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_bytes { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_bytes(bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, + 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, + 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_bytes { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_bytes> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. +```solidity +event log_bytes32(bytes32); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_bytes32 { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_bytes32 { + type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_bytes32(bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, + 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, + 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_bytes32 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_bytes32> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. +```solidity +event log_int(int256); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_int { + #[allow(missing_docs)] + pub _0: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_int { + type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_int(int256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, + 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, + 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. +```solidity +event log_named_address(string key, address val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_address { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_address { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Address, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_address(string,address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, + 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, + 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_address { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_address> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. +```solidity +event log_named_array(string key, uint256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_0 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_0 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, + 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, + 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_0 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_0> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. +```solidity +event log_named_array(string key, int256[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_1 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_1 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,int256[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, + 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, + 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + , + > as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_1 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_1> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. +```solidity +event log_named_array(string key, address[] val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_array_2 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_array_2 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Array, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_array(string,address[])"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, + 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, + 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_array_2 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_array_2> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. +```solidity +event log_named_bytes(string key, bytes val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_bytes { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_bytes { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Bytes, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, + 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, + 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_bytes { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_bytes> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. +```solidity +event log_named_bytes32(string key, bytes32 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_bytes32 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_bytes32 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::FixedBytes<32>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, + 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, + 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_bytes32 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. +```solidity +event log_named_decimal_int(string key, int256 val, uint256 decimals); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_decimal_int { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::I256, + #[allow(missing_docs)] + pub decimals: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_decimal_int { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Int<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, + 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, + 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + key: data.0, + val: data.1, + decimals: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + as alloy_sol_types::SolType>::tokenize(&self.decimals), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_decimal_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. +```solidity +event log_named_decimal_uint(string key, uint256 val, uint256 decimals); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_decimal_uint { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub decimals: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_decimal_uint { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, + 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, + 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + key: data.0, + val: data.1, + decimals: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + as alloy_sol_types::SolType>::tokenize(&self.decimals), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. +```solidity +event log_named_int(string key, int256 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_int { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_int { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Int<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_int(string,int256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, + 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, + 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. +```solidity +event log_named_string(string key, string val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_string { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::String, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_string { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::String, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_string(string,string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, + 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, + 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_string { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_string> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. +```solidity +event log_named_uint(string key, uint256 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_uint { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_uint { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, + 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, + 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. +```solidity +event log_string(string); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_string { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_string { + type DataTuple<'a> = (alloy::sol_types::sol_data::String,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_string(string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, + 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, + 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_string { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_string> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_string) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. +```solidity +event log_uint(uint256); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_uint { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_uint { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_uint(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, + 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, + 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. +```solidity +event logs(bytes); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct logs { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for logs { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "logs(bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, + 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, + 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 logs { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&logs> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &logs) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. +```solidity +function IS_TEST() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IS_TESTCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IS_TESTReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IS_TESTCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IS_TESTCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IS_TESTReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IS_TESTReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for IS_TESTCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "IS_TEST()"; + const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: IS_TESTReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: IS_TESTReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. +```solidity +function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeArtifactsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeArtifactsReturn { + #[allow(missing_docs)] + pub excludedArtifacts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeArtifactsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeArtifactsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeArtifactsReturn) -> Self { + (value.excludedArtifacts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeArtifactsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedArtifacts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeArtifactsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeArtifacts()"; + const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeArtifactsReturn = r.into(); + r.excludedArtifacts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeArtifactsReturn = r.into(); + r.excludedArtifacts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. +```solidity +function excludeContracts() external view returns (address[] memory excludedContracts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeContractsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeContractsReturn { + #[allow(missing_docs)] + pub excludedContracts_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeContractsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeContractsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeContractsReturn) -> Self { + (value.excludedContracts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeContractsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedContracts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeContractsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeContracts()"; + const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeContractsReturn = r.into(); + r.excludedContracts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeContractsReturn = r.into(); + r.excludedContracts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. +```solidity +function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSelectorsReturn { + #[allow(missing_docs)] + pub excludedSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSelectorsReturn) -> Self { + (value.excludedSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + excludedSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeSelectors()"; + const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeSelectorsReturn = r.into(); + r.excludedSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeSelectorsReturn = r.into(); + r.excludedSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. +```solidity +function excludeSenders() external view returns (address[] memory excludedSenders_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSendersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct excludeSendersReturn { + #[allow(missing_docs)] + pub excludedSenders_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: excludeSendersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for excludeSendersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: excludeSendersReturn) -> Self { + (value.excludedSenders_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for excludeSendersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { excludedSenders_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for excludeSendersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "excludeSenders()"; + const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: excludeSendersReturn = r.into(); + r.excludedSenders_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: excludeSendersReturn = r.into(); + r.excludedSenders_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `failed()` and selector `0xba414fa6`. +```solidity +function failed() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct failedCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`failed()`](failedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct failedReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: failedCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for failedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: failedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for failedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for failedCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "failed()"; + const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: failedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: failedReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `setUp()` and selector `0x0a9254e4`. +```solidity +function setUp() external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct setUpCall; + ///Container type for the return parameters of the [`setUp()`](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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setUpCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for setUpReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl setUpReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for setUpCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = setUpReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "setUp()"; + const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + setUpReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. +```solidity +function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct simulateForkAndTransferCall { + #[allow(missing_docs)] + pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub sender: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct simulateForkAndTransferReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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::Uint<256>, + ); + #[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::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferCall) -> Self { + (value.forkAtBlock, value.sender, value.receiver, value.amount) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for simulateForkAndTransferCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + forkAtBlock: tuple.0, + sender: tuple.1, + receiver: tuple.2, + amount: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for simulateForkAndTransferReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl simulateForkAndTransferReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for simulateForkAndTransferCall { + type Parameters<'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::Uint<256>, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = simulateForkAndTransferReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; + const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), + ::tokenize( + &self.sender, + ), + ::tokenize( + &self.receiver, + ), + as alloy_sol_types::SolType>::tokenize(&self.amount), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + simulateForkAndTransferReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. +```solidity +function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactSelectorsReturn { + #[allow(missing_docs)] + pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactSelectorsReturn) -> Self { + (value.targetedArtifactSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedArtifactSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetArtifactSelectors()"; + const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetArtifacts()` and selector `0x85226c81`. +```solidity +function targetArtifacts() external view returns (string[] memory targetedArtifacts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactsReturn { + #[allow(missing_docs)] + pub targetedArtifacts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetArtifactsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsReturn) -> Self { + (value.targetedArtifacts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedArtifacts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetArtifactsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetArtifacts()"; + const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetContracts()` and selector `0x3f7286f4`. +```solidity +function targetContracts() external view returns (address[] memory targetedContracts_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetContractsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetContractsReturn { + #[allow(missing_docs)] + pub targetedContracts_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetContractsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetContractsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetContractsReturn) -> Self { + (value.targetedContracts_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetContractsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedContracts_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetContractsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetContracts()"; + const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetContractsReturn = r.into(); + r.targetedContracts_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetContractsReturn = r.into(); + r.targetedContracts_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. +```solidity +function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetInterfacesCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetInterfacesReturn { + #[allow(missing_docs)] + pub targetedInterfaces_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetInterfacesCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetInterfacesCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetInterfacesReturn) -> Self { + (value.targetedInterfaces_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetInterfacesReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedInterfaces_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetInterfacesCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetInterfaces()"; + const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetSelectors()` and selector `0x916a17c6`. +```solidity +function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSelectorsReturn { + #[allow(missing_docs)] + pub targetedSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetSelectorsReturn) -> Self { + (value.targetedSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetSelectors()"; + const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. +```solidity +function targetSenders() external view returns (address[] memory targetedSenders_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSendersCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetSendersReturn { + #[allow(missing_docs)] + pub targetedSenders_: 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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSendersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersReturn) -> Self { + (value.targetedSenders_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for targetSendersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { targetedSenders_: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetSendersCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetSenders()"; + const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: targetSendersReturn = r.into(); + r.targetedSenders_ + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: targetSendersReturn = r.into(); + r.targetedSenders_ + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `testShoebillStrategy()` and selector `0x95419e06`. +```solidity +function testShoebillStrategy() external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct testShoebillStrategyCall; + ///Container type for the return parameters of the [`testShoebillStrategy()`](testShoebillStrategyCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct testShoebillStrategyReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: testShoebillStrategyCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for testShoebillStrategyCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: testShoebillStrategyReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for testShoebillStrategyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl testShoebillStrategyReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for testShoebillStrategyCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = testShoebillStrategyReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "testShoebillStrategy()"; + const SELECTOR: [u8; 4] = [149u8, 65u8, 158u8, 6u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + testShoebillStrategyReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `token()` and selector `0xfc0c546a`. +```solidity +function token() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct tokenCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`token()`](tokenCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct tokenReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for tokenCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for tokenReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for tokenCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "token()"; + const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: tokenReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`ShoebillTBTCStrategyForked`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum ShoebillTBTCStrategyForkedCalls { + #[allow(missing_docs)] + IS_TEST(IS_TESTCall), + #[allow(missing_docs)] + excludeArtifacts(excludeArtifactsCall), + #[allow(missing_docs)] + excludeContracts(excludeContractsCall), + #[allow(missing_docs)] + excludeSelectors(excludeSelectorsCall), + #[allow(missing_docs)] + excludeSenders(excludeSendersCall), + #[allow(missing_docs)] + failed(failedCall), + #[allow(missing_docs)] + setUp(setUpCall), + #[allow(missing_docs)] + simulateForkAndTransfer(simulateForkAndTransferCall), + #[allow(missing_docs)] + targetArtifactSelectors(targetArtifactSelectorsCall), + #[allow(missing_docs)] + targetArtifacts(targetArtifactsCall), + #[allow(missing_docs)] + targetContracts(targetContractsCall), + #[allow(missing_docs)] + targetInterfaces(targetInterfacesCall), + #[allow(missing_docs)] + targetSelectors(targetSelectorsCall), + #[allow(missing_docs)] + targetSenders(targetSendersCall), + #[allow(missing_docs)] + testShoebillStrategy(testShoebillStrategyCall), + #[allow(missing_docs)] + token(tokenCall), + } + #[automatically_derived] + impl ShoebillTBTCStrategyForkedCalls { + /// 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]] = &[ + [10u8, 146u8, 84u8, 228u8], + [30u8, 215u8, 131u8, 28u8], + [42u8, 222u8, 56u8, 128u8], + [62u8, 94u8, 60u8, 35u8], + [63u8, 114u8, 134u8, 244u8], + [102u8, 217u8, 169u8, 160u8], + [133u8, 34u8, 108u8, 129u8], + [145u8, 106u8, 23u8, 198u8], + [149u8, 65u8, 158u8, 6u8], + [176u8, 70u8, 79u8, 220u8], + [181u8, 80u8, 138u8, 169u8], + [186u8, 65u8, 79u8, 166u8], + [226u8, 12u8, 159u8, 113u8], + [249u8, 206u8, 14u8, 90u8], + [250u8, 118u8, 38u8, 212u8], + [252u8, 12u8, 84u8, 106u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for ShoebillTBTCStrategyForkedCalls { + const NAME: &'static str = "ShoebillTBTCStrategyForkedCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 16usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::IS_TEST(_) => ::SELECTOR, + Self::excludeArtifacts(_) => { + ::SELECTOR + } + Self::excludeContracts(_) => { + ::SELECTOR + } + Self::excludeSelectors(_) => { + ::SELECTOR + } + Self::excludeSenders(_) => { + ::SELECTOR + } + Self::failed(_) => ::SELECTOR, + Self::setUp(_) => ::SELECTOR, + Self::simulateForkAndTransfer(_) => { + ::SELECTOR + } + Self::targetArtifactSelectors(_) => { + ::SELECTOR + } + Self::targetArtifacts(_) => { + ::SELECTOR + } + Self::targetContracts(_) => { + ::SELECTOR + } + Self::targetInterfaces(_) => { + ::SELECTOR + } + Self::targetSelectors(_) => { + ::SELECTOR + } + Self::targetSenders(_) => { + ::SELECTOR + } + Self::testShoebillStrategy(_) => { + ::SELECTOR + } + Self::token(_) => ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn setUp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ShoebillTBTCStrategyForkedCalls::setUp) + } + setUp + }, + { + fn excludeSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::excludeSenders) + } + excludeSenders + }, + { + fn targetInterfaces( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::targetInterfaces) + } + targetInterfaces + }, + { + fn targetSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::targetSenders) + } + targetSenders + }, + { + fn targetContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::targetContracts) + } + targetContracts + }, + { + fn targetArtifactSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + ShoebillTBTCStrategyForkedCalls::targetArtifactSelectors, + ) + } + targetArtifactSelectors + }, + { + fn targetArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::targetArtifacts) + } + targetArtifacts + }, + { + fn targetSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::targetSelectors) + } + targetSelectors + }, + { + fn testShoebillStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::testShoebillStrategy) + } + testShoebillStrategy + }, + { + fn excludeSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::excludeSelectors) + } + excludeSelectors + }, + { + fn excludeArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::excludeArtifacts) + } + excludeArtifacts + }, + { + fn failed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ShoebillTBTCStrategyForkedCalls::failed) + } + failed + }, + { + fn excludeContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::excludeContracts) + } + excludeContracts + }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + ShoebillTBTCStrategyForkedCalls::simulateForkAndTransfer, + ) + } + simulateForkAndTransfer + }, + { + fn IS_TEST( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ShoebillTBTCStrategyForkedCalls::IS_TEST) + } + IS_TEST + }, + { + fn token( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(ShoebillTBTCStrategyForkedCalls::token) + } + token + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn setUp( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::setUp) + } + setUp + }, + { + fn excludeSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::excludeSenders) + } + excludeSenders + }, + { + fn targetInterfaces( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::targetInterfaces) + } + targetInterfaces + }, + { + fn targetSenders( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::targetSenders) + } + targetSenders + }, + { + fn targetContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::targetContracts) + } + targetContracts + }, + { + fn targetArtifactSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + ShoebillTBTCStrategyForkedCalls::targetArtifactSelectors, + ) + } + targetArtifactSelectors + }, + { + fn targetArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::targetArtifacts) + } + targetArtifacts + }, + { + fn targetSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::targetSelectors) + } + targetSelectors + }, + { + fn testShoebillStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::testShoebillStrategy) + } + testShoebillStrategy + }, + { + fn excludeSelectors( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::excludeSelectors) + } + excludeSelectors + }, + { + fn excludeArtifacts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::excludeArtifacts) + } + excludeArtifacts + }, + { + fn failed( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::failed) + } + failed + }, + { + fn excludeContracts( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::excludeContracts) + } + excludeContracts + }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + ShoebillTBTCStrategyForkedCalls::simulateForkAndTransfer, + ) + } + simulateForkAndTransfer + }, + { + fn IS_TEST( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::IS_TEST) + } + IS_TEST + }, + { + fn token( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(ShoebillTBTCStrategyForkedCalls::token) + } + token + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::IS_TEST(inner) => { + ::abi_encoded_size(inner) + } + Self::excludeArtifacts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeContracts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::excludeSenders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::failed(inner) => { + ::abi_encoded_size(inner) + } + Self::setUp(inner) => { + ::abi_encoded_size(inner) + } + Self::simulateForkAndTransfer(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetArtifactSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetArtifacts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetContracts(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetInterfaces(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetSelectors(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::targetSenders(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::testShoebillStrategy(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::token(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::IS_TEST(inner) => { + ::abi_encode_raw(inner, out) + } + Self::excludeArtifacts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeContracts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::excludeSenders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::failed(inner) => { + ::abi_encode_raw(inner, out) + } + Self::setUp(inner) => { + ::abi_encode_raw(inner, out) + } + Self::simulateForkAndTransfer(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetArtifactSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetArtifacts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetContracts(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetInterfaces(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetSelectors(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::targetSenders(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::testShoebillStrategy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::token(inner) => { + ::abi_encode_raw(inner, out) + } + } + } + } + ///Container for all the [`ShoebillTBTCStrategyForked`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum ShoebillTBTCStrategyForkedEvents { + #[allow(missing_docs)] + log(log), + #[allow(missing_docs)] + log_address(log_address), + #[allow(missing_docs)] + log_array_0(log_array_0), + #[allow(missing_docs)] + log_array_1(log_array_1), + #[allow(missing_docs)] + log_array_2(log_array_2), + #[allow(missing_docs)] + log_bytes(log_bytes), + #[allow(missing_docs)] + log_bytes32(log_bytes32), + #[allow(missing_docs)] + log_int(log_int), + #[allow(missing_docs)] + log_named_address(log_named_address), + #[allow(missing_docs)] + log_named_array_0(log_named_array_0), + #[allow(missing_docs)] + log_named_array_1(log_named_array_1), + #[allow(missing_docs)] + log_named_array_2(log_named_array_2), + #[allow(missing_docs)] + log_named_bytes(log_named_bytes), + #[allow(missing_docs)] + log_named_bytes32(log_named_bytes32), + #[allow(missing_docs)] + log_named_decimal_int(log_named_decimal_int), + #[allow(missing_docs)] + log_named_decimal_uint(log_named_decimal_uint), + #[allow(missing_docs)] + log_named_int(log_named_int), + #[allow(missing_docs)] + log_named_string(log_named_string), + #[allow(missing_docs)] + log_named_uint(log_named_uint), + #[allow(missing_docs)] + log_string(log_string), + #[allow(missing_docs)] + log_uint(log_uint), + #[allow(missing_docs)] + logs(logs), + } + #[automatically_derived] + impl ShoebillTBTCStrategyForkedEvents { + /// 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]] = &[ + [ + 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, + 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, + 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, + ], + [ + 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, + 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, + 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, + ], + [ + 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, + 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, + 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, + ], + [ + 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, + 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, + 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, + ], + [ + 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, + 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, + 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, + ], + [ + 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, + 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, + 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, + ], + [ + 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, + 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, + 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, + ], + [ + 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, + 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, + 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, + ], + [ + 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, + 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, + 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, + ], + [ + 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, + 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, + 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, + ], + [ + 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, + 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, + 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, + ], + [ + 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, + 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, + 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, + ], + [ + 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, + 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, + 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, + ], + [ + 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, + 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, + 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, + ], + [ + 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, + 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, + 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, + ], + [ + 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, + 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, + 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, + ], + [ + 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, + 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, + 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, + ], + [ + 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, + 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, + 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, + ], + [ + 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, + 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, + 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, + ], + [ + 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, + 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, + 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, + ], + [ + 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, + 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, + 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, + ], + [ + 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, + 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, + 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for ShoebillTBTCStrategyForkedEvents { + const NAME: &'static str = "ShoebillTBTCStrategyForkedEvents"; + const COUNT: usize = 22usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_address) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_0) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_1) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_array_2) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_bytes) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_bytes32) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log_int) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_address) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_0) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_1) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_array_2) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_bytes) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_bytes32) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_decimal_int) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_decimal_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_int) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_string) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_string) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::logs) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 ShoebillTBTCStrategyForkedEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::log(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_address(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_0(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_1(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_array_2(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_bytes(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_address(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_0(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_1(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_array_2(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_bytes(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_decimal_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_decimal_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_string(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_string(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::logs(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::log(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_address(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_0(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_1(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_array_2(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_bytes(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_address(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_0(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_1(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_array_2(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_bytes(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_decimal_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_decimal_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_string(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_string(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::logs(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`ShoebillTBTCStrategyForked`](self) contract instance. + +See the [wrapper's documentation](`ShoebillTBTCStrategyForkedInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> ShoebillTBTCStrategyForkedInstance { + ShoebillTBTCStrategyForkedInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + ShoebillTBTCStrategyForkedInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + ShoebillTBTCStrategyForkedInstance::::deploy_builder(provider) + } + /**A [`ShoebillTBTCStrategyForked`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`ShoebillTBTCStrategyForked`](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 ShoebillTBTCStrategyForkedInstance< + P, + N = alloy_contract::private::Ethereum, + > { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for ShoebillTBTCStrategyForkedInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("ShoebillTBTCStrategyForkedInstance") + .field(&self.address) + .finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ShoebillTBTCStrategyForkedInstance { + /**Creates a new wrapper around an on-chain [`ShoebillTBTCStrategyForked`](self) contract instance. + +See the [wrapper's documentation](`ShoebillTBTCStrategyForkedInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 ShoebillTBTCStrategyForkedInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> ShoebillTBTCStrategyForkedInstance { + ShoebillTBTCStrategyForkedInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ShoebillTBTCStrategyForkedInstance { + /// 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( + &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 [`IS_TEST`] function. + pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { + self.call_builder(&IS_TESTCall) + } + ///Creates a new call builder for the [`excludeArtifacts`] function. + pub fn excludeArtifacts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { + self.call_builder(&excludeArtifactsCall) + } + ///Creates a new call builder for the [`excludeContracts`] function. + pub fn excludeContracts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { + self.call_builder(&excludeContractsCall) + } + ///Creates a new call builder for the [`excludeSelectors`] function. + pub fn excludeSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { + self.call_builder(&excludeSelectorsCall) + } + ///Creates a new call builder for the [`excludeSenders`] function. + pub fn excludeSenders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { + self.call_builder(&excludeSendersCall) + } + ///Creates a new call builder for the [`failed`] function. + pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { + self.call_builder(&failedCall) + } + ///Creates a new call builder for the [`setUp`] function. + pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { + self.call_builder(&setUpCall) + } + ///Creates a new call builder for the [`simulateForkAndTransfer`] function. + pub fn simulateForkAndTransfer( + &self, + forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + sender: alloy::sol_types::private::Address, + receiver: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { + self.call_builder( + &simulateForkAndTransferCall { + forkAtBlock, + sender, + receiver, + amount, + }, + ) + } + ///Creates a new call builder for the [`targetArtifactSelectors`] function. + pub fn targetArtifactSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { + self.call_builder(&targetArtifactSelectorsCall) + } + ///Creates a new call builder for the [`targetArtifacts`] function. + pub fn targetArtifacts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { + self.call_builder(&targetArtifactsCall) + } + ///Creates a new call builder for the [`targetContracts`] function. + pub fn targetContracts( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { + self.call_builder(&targetContractsCall) + } + ///Creates a new call builder for the [`targetInterfaces`] function. + pub fn targetInterfaces( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { + self.call_builder(&targetInterfacesCall) + } + ///Creates a new call builder for the [`targetSelectors`] function. + pub fn targetSelectors( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { + self.call_builder(&targetSelectorsCall) + } + ///Creates a new call builder for the [`targetSenders`] function. + pub fn targetSenders( + &self, + ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { + self.call_builder(&targetSendersCall) + } + ///Creates a new call builder for the [`testShoebillStrategy`] function. + pub fn testShoebillStrategy( + &self, + ) -> alloy_contract::SolCallBuilder<&P, testShoebillStrategyCall, N> { + self.call_builder(&testShoebillStrategyCall) + } + ///Creates a new call builder for the [`token`] function. + pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { + self.call_builder(&tokenCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ShoebillTBTCStrategyForkedInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`log`] event. + pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_address`] event. + pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_0`] event. + pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_1`] event. + pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_array_2`] event. + pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_bytes`] event. + pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_bytes32`] event. + pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_int`] event. + pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_address`] event. + pub fn log_named_address_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_address, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_0`] event. + pub fn log_named_array_0_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_0, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_1`] event. + pub fn log_named_array_1_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_1, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_array_2`] event. + pub fn log_named_array_2_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_array_2, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_bytes`] event. + pub fn log_named_bytes_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_bytes, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_bytes32`] event. + pub fn log_named_bytes32_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_bytes32, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_decimal_int`] event. + pub fn log_named_decimal_int_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_decimal_uint`] event. + pub fn log_named_decimal_uint_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_int`] event. + pub fn log_named_int_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_string`] event. + pub fn log_named_string_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_string, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_uint`] event. + pub fn log_named_uint_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_string`] event. + pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_uint`] event. + pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`logs`] event. + pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/solv_btc_strategy.rs b/crates/bindings/src/solv_btc_strategy.rs new file mode 100644 index 000000000..0a3171835 --- /dev/null +++ b/crates/bindings/src/solv_btc_strategy.rs @@ -0,0 +1,2006 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface SolvBTCStrategy { + struct StrategySlippageArgs { + uint256 amountOutMin; + } + + event TokenOutput(address tokenReceived, uint256 amountOut); + + constructor(address _solvBTCRouter, bytes32 _poolId, address _solvBTC); + + function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; + function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; + function poolId() external view returns (bytes32); + function solvBTC() external view returns (address); + function solvBTCRouter() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_solvBTCRouter", + "type": "address", + "internalType": "contract ISolvBTCRouter" + }, + { + "name": "_poolId", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "_solvBTC", + "type": "address", + "internalType": "contract IERC20" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessage", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "message", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessageWithSlippageArgs", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "args", + "type": "tuple", + "internalType": "struct StrategySlippageArgs", + "components": [ + { + "name": "amountOutMin", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "poolId", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "solvBTC", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IERC20" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "solvBTCRouter", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract ISolvBTCRouter" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "TokenOutput", + "inputs": [ + { + "name": "tokenReceived", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "amountOut", + "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 SolvBTCStrategy { + use super::*; + use alloy::sol_types as 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\x15a\0\x0FW__\xFD[P`@Qa\x0C\xE38\x03\x80a\x0C\xE3\x839\x81\x01`@\x81\x90Ra\0.\x91a\0bV[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16`\x80R`\xA0\x91\x90\x91R\x16`\xC0Ra\0\xA2V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0_W__\xFD[PV[___``\x84\x86\x03\x12\x15a\0tW__\xFD[\x83Qa\0\x7F\x81a\0KV[` \x85\x01Q`@\x86\x01Q\x91\x94P\x92Pa\0\x97\x81a\0KV[\x80\x91PP\x92P\x92P\x92V[`\x80Q`\xA0Q`\xC0Qa\x0B\xF6a\0\xED_9_\x81\x81a\x01\x1B\x01R\x81\x81a\x03-\x01Ra\x03o\x01R_\x81\x81`\xBE\x01Ra\x01\xF2\x01R_\x81\x81`m\x01R\x81\x81a\x01\xA5\x01Ra\x02!\x01Ra\x0B\xF6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0dW_5`\xE0\x1C\x80cPcL\x0E\x11a\0MW\x80cPcL\x0E\x14a\0\xEEW\x80c\x7F\x81O5\x14a\x01\x03W\x80c\xB9\x93|\xCB\x14a\x01\x16W__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0hW\x80c>\r\xC3N\x14a\0\xB9W[__\xFD[a\0\x8F\x7F\0\0\0\0\0\0\0\0\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\xE0\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xB0V[a\x01\x01a\0\xFC6`\x04a\t\x97V[a\x01=V[\0[a\x01\x01a\x01\x116`\x04a\nYV[a\x01gV[a\0\x8F\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01R\x91\x90a\n\xDDV[\x90Pa\x01`\x85\x85\x85\x84a\x01gV[PPPPPV[a\x01\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x03\xCAV[a\x01\xCAs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\x8EV[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02|W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xA0\x91\x90a\x0B\x01V[\x82Q\x90\x91P\x81\x10\x15a\x03\x13W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03Ts\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\x84\x83a\x05\x89V[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\x88\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xE4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x02W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05&\x91\x90a\x0B\x01V[a\x050\x91\x90a\x0B\x18V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\x88\x90\x85\x90\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\x90`d\x01a\x04$V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x05\xDF\x90\x84\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\x90`d\x01a\x04$V[PPPV[_a\x06E\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\x06\xEF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x05\xDFW\x80\x80` \x01\x90Q\x81\x01\x90a\x06c\x91\x90a\x0BVV[a\x05\xDFW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[``a\x06\xFD\x84\x84_\x85a\x07\x07V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\x99W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\x17W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[__\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\x08?\x91\x90a\x0BuV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08yW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08~V[``\x91P[P\x91P\x91Pa\x08\x8E\x82\x82\x86a\x08\x99V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xA8WP\x81a\x07\0V[\x82Q\x15a\x08\xB8W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\n\x91\x90a\x0B\x8BV[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\t\rW__\xFD[PV[\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`Wa\t`a\t\x10V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\x8FWa\t\x8Fa\t\x10V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xAAW__\xFD[\x845a\t\xB5\x81a\x08\xECV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xCC\x81a\x08\xECV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xE7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\t\xF7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x11Wa\n\x11a\t\x10V[a\n$` `\x1F\x19`\x1F\x84\x01\x16\x01a\tfV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n8W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\nmW__\xFD[\x855a\nx\x81a\x08\xECV[\x94P` \x86\x015\x93P`@\x86\x015a\n\x8F\x81a\x08\xECV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xC0W__\xFD[Pa\n\xC9a\t=V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\n\xEEW__\xFD[Pa\n\xF7a\t=V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\x11W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0BPW\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[_` \x82\x84\x03\x12\x15a\x0BfW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\0W__\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\xFE\xA2dipfsX\"\x12 \xEA:\x8D\x8D\x03\xA7\x99\xDE\xBEZ\xF3\x80t\xA1\xC6S\x89f\xE8#\xECG\xA2\xDDfH\x1F<\x94\xF2SxdsolcC\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\0dW_5`\xE0\x1C\x80cPcL\x0E\x11a\0MW\x80cPcL\x0E\x14a\0\xEEW\x80c\x7F\x81O5\x14a\x01\x03W\x80c\xB9\x93|\xCB\x14a\x01\x16W__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0hW\x80c>\r\xC3N\x14a\0\xB9W[__\xFD[a\0\x8F\x7F\0\0\0\0\0\0\0\0\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\xE0\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xB0V[a\x01\x01a\0\xFC6`\x04a\t\x97V[a\x01=V[\0[a\x01\x01a\x01\x116`\x04a\nYV[a\x01gV[a\0\x8F\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01R\x91\x90a\n\xDDV[\x90Pa\x01`\x85\x85\x85\x84a\x01gV[PPPPPV[a\x01\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x03\xCAV[a\x01\xCAs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\x8EV[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02|W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xA0\x91\x90a\x0B\x01V[\x82Q\x90\x91P\x81\x10\x15a\x03\x13W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03Ts\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\x84\x83a\x05\x89V[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\x88\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xE4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x02W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05&\x91\x90a\x0B\x01V[a\x050\x91\x90a\x0B\x18V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\x88\x90\x85\x90\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\x90`d\x01a\x04$V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x05\xDF\x90\x84\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\x90`d\x01a\x04$V[PPPV[_a\x06E\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\x06\xEF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x05\xDFW\x80\x80` \x01\x90Q\x81\x01\x90a\x06c\x91\x90a\x0BVV[a\x05\xDFW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[``a\x06\xFD\x84\x84_\x85a\x07\x07V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\x99W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\x17W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[__\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\x08?\x91\x90a\x0BuV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08yW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08~V[``\x91P[P\x91P\x91Pa\x08\x8E\x82\x82\x86a\x08\x99V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xA8WP\x81a\x07\0V[\x82Q\x15a\x08\xB8W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\n\x91\x90a\x0B\x8BV[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\t\rW__\xFD[PV[\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`Wa\t`a\t\x10V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\x8FWa\t\x8Fa\t\x10V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xAAW__\xFD[\x845a\t\xB5\x81a\x08\xECV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xCC\x81a\x08\xECV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xE7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\t\xF7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x11Wa\n\x11a\t\x10V[a\n$` `\x1F\x19`\x1F\x84\x01\x16\x01a\tfV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n8W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\nmW__\xFD[\x855a\nx\x81a\x08\xECV[\x94P` \x86\x015\x93P`@\x86\x015a\n\x8F\x81a\x08\xECV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xC0W__\xFD[Pa\n\xC9a\t=V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\n\xEEW__\xFD[Pa\n\xF7a\t=V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\x11W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0BPW\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[_` \x82\x84\x03\x12\x15a\x0BfW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\0W__\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\xFE\xA2dipfsX\"\x12 \xEA:\x8D\x8D\x03\xA7\x99\xDE\xBEZ\xF3\x80t\xA1\xC6S\x89f\xE8#\xECG\xA2\xDDfH\x1F<\x94\xF2SxdsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct StrategySlippageArgs { uint256 amountOutMin; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct StrategySlippageArgs { + #[allow(missing_docs)] + pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: StrategySlippageArgs) -> Self { + (value.amountOutMin,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for StrategySlippageArgs { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { amountOutMin: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for StrategySlippageArgs { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for StrategySlippageArgs { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for StrategySlippageArgs { + const NAME: &'static str = "StrategySlippageArgs"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "StrategySlippageArgs(uint256 amountOutMin)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) + .0 + .to_vec() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for StrategySlippageArgs { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.amountOutMin, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.amountOutMin, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. +```solidity +event TokenOutput(address tokenReceived, uint256 amountOut); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct TokenOutput { + #[allow(missing_docs)] + pub tokenReceived: alloy::sol_types::private::Address, + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for TokenOutput { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + tokenReceived: data.0, + amountOut: data.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.tokenReceived, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountOut), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 TokenOutput { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&TokenOutput> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(address _solvBTCRouter, bytes32 _poolId, address _solvBTC); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _solvBTCRouter: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _poolId: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub _solvBTC: alloy::sol_types::private::Address, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + (value._solvBTCRouter, value._poolId, value._solvBTC) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _solvBTCRouter: tuple.0, + _poolId: tuple.1, + _solvBTC: 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::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._solvBTCRouter, + ), + as alloy_sol_types::SolType>::tokenize(&self._poolId), + ::tokenize( + &self._solvBTC, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. +```solidity +function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub message: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ); + #[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, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.message) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + message: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageCall { + 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, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; + const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.message, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. +```solidity +function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub args: ::RustType, + } + ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Address, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.args) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + args: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageWithSlippageArgsReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageWithSlippageArgsReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; + const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.args, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `poolId()` and selector `0x3e0dc34e`. +```solidity +function poolId() external view returns (bytes32); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct poolIdCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`poolId()`](poolIdCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct poolIdReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: poolIdCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for poolIdCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: poolIdReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for poolIdReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for poolIdCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::FixedBytes<32>; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "poolId()"; + const SELECTOR: [u8; 4] = [62u8, 13u8, 195u8, 78u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: poolIdReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: poolIdReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `solvBTC()` and selector `0xb9937ccb`. +```solidity +function solvBTC() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct solvBTCCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`solvBTC()`](solvBTCCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct solvBTCReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: solvBTCCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for solvBTCCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: solvBTCReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for solvBTCReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for solvBTCCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "solvBTC()"; + const SELECTOR: [u8; 4] = [185u8, 147u8, 124u8, 203u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: solvBTCReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: solvBTCReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `solvBTCRouter()` and selector `0x06af019a`. +```solidity +function solvBTCRouter() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct solvBTCRouterCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`solvBTCRouter()`](solvBTCRouterCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct solvBTCRouterReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: solvBTCRouterCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for solvBTCRouterCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: solvBTCRouterReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for solvBTCRouterReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for solvBTCRouterCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "solvBTCRouter()"; + const SELECTOR: [u8; 4] = [6u8, 175u8, 1u8, 154u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: solvBTCRouterReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: solvBTCRouterReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`SolvBTCStrategy`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum SolvBTCStrategyCalls { + #[allow(missing_docs)] + handleGatewayMessage(handleGatewayMessageCall), + #[allow(missing_docs)] + handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), + #[allow(missing_docs)] + poolId(poolIdCall), + #[allow(missing_docs)] + solvBTC(solvBTCCall), + #[allow(missing_docs)] + solvBTCRouter(solvBTCRouterCall), + } + #[automatically_derived] + impl SolvBTCStrategyCalls { + /// 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, 175u8, 1u8, 154u8], + [62u8, 13u8, 195u8, 78u8], + [80u8, 99u8, 76u8, 14u8], + [127u8, 129u8, 79u8, 53u8], + [185u8, 147u8, 124u8, 203u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for SolvBTCStrategyCalls { + const NAME: &'static str = "SolvBTCStrategyCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 5usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::handleGatewayMessage(_) => { + ::SELECTOR + } + Self::handleGatewayMessageWithSlippageArgs(_) => { + ::SELECTOR + } + Self::poolId(_) => ::SELECTOR, + Self::solvBTC(_) => ::SELECTOR, + Self::solvBTCRouter(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn solvBTCRouter( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SolvBTCStrategyCalls::solvBTCRouter) + } + solvBTCRouter + }, + { + fn poolId( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(SolvBTCStrategyCalls::poolId) + } + poolId + }, + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SolvBTCStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + SolvBTCStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + { + fn solvBTC( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(SolvBTCStrategyCalls::solvBTC) + } + solvBTC + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn solvBTCRouter( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SolvBTCStrategyCalls::solvBTCRouter) + } + solvBTCRouter + }, + { + fn poolId( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SolvBTCStrategyCalls::poolId) + } + poolId + }, + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SolvBTCStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + SolvBTCStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + { + fn solvBTC( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SolvBTCStrategyCalls::solvBTC) + } + solvBTC + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::handleGatewayMessage(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::poolId(inner) => { + ::abi_encoded_size(inner) + } + Self::solvBTC(inner) => { + ::abi_encoded_size(inner) + } + Self::solvBTCRouter(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::handleGatewayMessage(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::poolId(inner) => { + ::abi_encode_raw(inner, out) + } + Self::solvBTC(inner) => { + ::abi_encode_raw(inner, out) + } + Self::solvBTCRouter(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`SolvBTCStrategy`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum SolvBTCStrategyEvents { + #[allow(missing_docs)] + TokenOutput(TokenOutput), + } + #[automatically_derived] + impl SolvBTCStrategyEvents { + /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for SolvBTCStrategyEvents { + const NAME: &'static str = "SolvBTCStrategyEvents"; + const COUNT: usize = 1usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::TokenOutput) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 SolvBTCStrategyEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`SolvBTCStrategy`](self) contract instance. + +See the [wrapper's documentation](`SolvBTCStrategyInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> SolvBTCStrategyInstance { + SolvBTCStrategyInstance::::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: alloy_contract::private::Network, + >( + provider: P, + _solvBTCRouter: alloy::sol_types::private::Address, + _poolId: alloy::sol_types::private::FixedBytes<32>, + _solvBTC: alloy::sol_types::private::Address, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + SolvBTCStrategyInstance::< + P, + N, + >::deploy(provider, _solvBTCRouter, _poolId, _solvBTC) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + _solvBTCRouter: alloy::sol_types::private::Address, + _poolId: alloy::sol_types::private::FixedBytes<32>, + _solvBTC: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + SolvBTCStrategyInstance::< + P, + N, + >::deploy_builder(provider, _solvBTCRouter, _poolId, _solvBTC) + } + /**A [`SolvBTCStrategy`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`SolvBTCStrategy`](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 SolvBTCStrategyInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for SolvBTCStrategyInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("SolvBTCStrategyInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SolvBTCStrategyInstance { + /**Creates a new wrapper around an on-chain [`SolvBTCStrategy`](self) contract instance. + +See the [wrapper's documentation](`SolvBTCStrategyInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + _solvBTCRouter: alloy::sol_types::private::Address, + _poolId: alloy::sol_types::private::FixedBytes<32>, + _solvBTC: alloy::sol_types::private::Address, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder( + provider, + _solvBTCRouter, + _poolId, + _solvBTC, + ); + 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, + _solvBTCRouter: alloy::sol_types::private::Address, + _poolId: alloy::sol_types::private::FixedBytes<32>, + _solvBTC: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + _solvBTCRouter, + _poolId, + _solvBTC, + }, + )[..], + ] + .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 SolvBTCStrategyInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> SolvBTCStrategyInstance { + SolvBTCStrategyInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SolvBTCStrategyInstance { + /// 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( + &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 [`handleGatewayMessage`] function. + pub fn handleGatewayMessage( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + message: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { + self.call_builder( + &handleGatewayMessageCall { + tokenSent, + amountIn, + recipient, + message, + }, + ) + } + ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. + pub fn handleGatewayMessageWithSlippageArgs( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + args: ::RustType, + ) -> alloy_contract::SolCallBuilder< + &P, + handleGatewayMessageWithSlippageArgsCall, + N, + > { + self.call_builder( + &handleGatewayMessageWithSlippageArgsCall { + tokenSent, + amountIn, + recipient, + args, + }, + ) + } + ///Creates a new call builder for the [`poolId`] function. + pub fn poolId(&self) -> alloy_contract::SolCallBuilder<&P, poolIdCall, N> { + self.call_builder(&poolIdCall) + } + ///Creates a new call builder for the [`solvBTC`] function. + pub fn solvBTC(&self) -> alloy_contract::SolCallBuilder<&P, solvBTCCall, N> { + self.call_builder(&solvBTCCall) + } + ///Creates a new call builder for the [`solvBTCRouter`] function. + pub fn solvBTCRouter( + &self, + ) -> alloy_contract::SolCallBuilder<&P, solvBTCRouterCall, N> { + self.call_builder(&solvBTCRouterCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SolvBTCStrategyInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`TokenOutput`] event. + pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/solv_lst_strategy.rs b/crates/bindings/src/solv_lst_strategy.rs new file mode 100644 index 000000000..1d5d910a1 --- /dev/null +++ b/crates/bindings/src/solv_lst_strategy.rs @@ -0,0 +1,2695 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface SolvLSTStrategy { + struct StrategySlippageArgs { + uint256 amountOutMin; + } + + event TokenOutput(address tokenReceived, uint256 amountOut); + + constructor(address _solvBTCRouter, address _solvLSTRouter, bytes32 _solvBTCPoolId, bytes32 _solvLSTPoolId, address _solvBTC, address _solvLST); + + function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; + function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; + function solvBTC() external view returns (address); + function solvBTCPoolId() external view returns (bytes32); + function solvBTCRouter() external view returns (address); + function solvLST() external view returns (address); + function solvLSTPoolId() external view returns (bytes32); + function solvLSTRouter() external view returns (address); +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_solvBTCRouter", + "type": "address", + "internalType": "contract ISolvBTCRouter" + }, + { + "name": "_solvLSTRouter", + "type": "address", + "internalType": "contract ISolvBTCRouter" + }, + { + "name": "_solvBTCPoolId", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "_solvLSTPoolId", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "_solvBTC", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "_solvLST", + "type": "address", + "internalType": "contract IERC20" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessage", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "message", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "handleGatewayMessageWithSlippageArgs", + "inputs": [ + { + "name": "tokenSent", + "type": "address", + "internalType": "contract IERC20" + }, + { + "name": "amountIn", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "recipient", + "type": "address", + "internalType": "address" + }, + { + "name": "args", + "type": "tuple", + "internalType": "struct StrategySlippageArgs", + "components": [ + { + "name": "amountOutMin", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "solvBTC", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IERC20" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "solvBTCPoolId", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "solvBTCRouter", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract ISolvBTCRouter" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "solvLST", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IERC20" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "solvLSTPoolId", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "solvLSTRouter", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract ISolvBTCRouter" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "TokenOutput", + "inputs": [ + { + "name": "tokenReceived", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "amountOut", + "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 SolvLSTStrategy { + use super::*; + use alloy::sol_types as 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__\xFD[P`@Qa\x0F-8\x03\x80a\x0F-\x839\x81\x01`@\x81\x90Ra\0/\x91a\0sV[`\x01`\x01`\xA0\x1B\x03\x95\x86\x16`\x80R\x93\x85\x16`\xA0R`\xC0\x92\x90\x92R`\xE0R\x82\x16a\x01\0R\x16a\x01 Ra\0\xE3V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0pW__\xFD[PV[______`\xC0\x87\x89\x03\x12\x15a\0\x88W__\xFD[\x86Qa\0\x93\x81a\0\\V[` \x88\x01Q\x90\x96Pa\0\xA4\x81a\0\\V[`@\x88\x01Q``\x89\x01Q`\x80\x8A\x01Q\x92\x97P\x90\x95P\x93Pa\0\xC4\x81a\0\\V[`\xA0\x88\x01Q\x90\x92Pa\0\xD5\x81a\0\\V[\x80\x91PP\x92\x95P\x92\x95P\x92\x95V[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\r\xC6a\x01g_9_\x81\x81a\x01.\x01R\x81\x81a\x04\xFC\x01Ra\x05>\x01R_\x81\x81a\x01U\x01Ra\x03R\x01R_\x81\x81a\x01\xB1\x01Ra\x03\xC1\x01R_\x81\x81a\x01|\x01Ra\x02\x88\x01R_\x81\x81`\xDF\x01R\x81\x81a\x03t\x01Ra\x03\xF0\x01R_\x81\x81`\x8E\x01R\x81\x81a\x02;\x01Ra\x02\xB7\x01Ra\r\xC6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\x85W_5`\xE0\x1C\x80c\xADt}\xE6\x11a\0XW\x80c\xADt}\xE6\x14a\x01)W\x80c\xB9\x93|\xCB\x14a\x01PW\x80c\xC8\xC7\xF7\x01\x14a\x01wW\x80c\xE3L\xEF\x86\x14a\x01\xACW__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0\x89W\x80cN=\xF3\xF4\x14a\0\xDAW\x80cPcL\x0E\x14a\x01\x01W\x80c\x7F\x81O5\x14a\x01\x16W[__\xFD[a\0\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\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\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\x81V[a\x01\x14a\x01\x0F6`\x04a\x0BgV[a\x01\xD3V[\0[a\x01\x14a\x01$6`\x04a\x0C)V[a\x01\xFDV[a\0\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\x81V[a\0\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\x81V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xD1V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\xE8\x91\x90a\x0C\xADV[\x90Pa\x01\xF6\x85\x85\x85\x84a\x01\xFDV[PPPPPV[a\x02\x1Fs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x9AV[a\x02`s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x036\x91\x90a\x0C\xD1V[\x90Pa\x03\x99s\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\x7F\0\0\0\0\0\0\0\0\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\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x82\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04KW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04o\x91\x90a\x0C\xD1V[\x83Q\x90\x91P\x81\x10\x15a\x04\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[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\x85\x83a\x07YV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x06X\x90\x85\x90\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\x90`\x84\x01[`@\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\x07\xB4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF6\x91\x90a\x0C\xD1V[a\x07\0\x91\x90a\x0C\xE8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x06X\x90\x85\x90\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\x90`d\x01a\x05\xF4V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07\xAF\x90\x84\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\x90`d\x01a\x05\xF4V[PPPV[_a\x08\x15\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\x08\xBF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\xAFW\x80\x80` \x01\x90Q\x81\x01\x90a\x083\x91\x90a\r&V[a\x07\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\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\x04\xD9V[``a\x08\xCD\x84\x84_\x85a\x08\xD7V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\tiW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x04\xD9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\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`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x04\xD9V[__\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\n\x0F\x91\x90a\rEV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\nIW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\nNV[``\x91P[P\x91P\x91Pa\n^\x82\x82\x86a\niV[\x97\x96PPPPPPPV[``\x83\x15a\nxWP\x81a\x08\xD0V[\x82Q\x15a\n\x88W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x04\xD9\x91\x90a\r[V[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\xDDW__\xFD[PV[\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\x0B0Wa\x0B0a\n\xE0V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0B_Wa\x0B_a\n\xE0V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0BzW__\xFD[\x845a\x0B\x85\x81a\n\xBCV[\x93P` \x85\x015\x92P`@\x85\x015a\x0B\x9C\x81a\n\xBCV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xB7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\x0B\xC7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xE1Wa\x0B\xE1a\n\xE0V[a\x0B\xF4` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0B6V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0C\x08W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0C=W__\xFD[\x855a\x0CH\x81a\n\xBCV[\x94P` \x86\x015\x93P`@\x86\x015a\x0C_\x81a\n\xBCV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0C\x90W__\xFD[Pa\x0C\x99a\x0B\rV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0C\xBEW__\xFD[Pa\x0C\xC7a\x0B\rV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C\xE1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\r 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[_` \x82\x84\x03\x12\x15a\r6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x08\xD0W__\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\xFE\xA2dipfsX\"\x12 \xD28\x8C\xB3\xDCz\xA6\xF5\xA2\xEBuA}\x11\x05\x9B\xE1<\x8C\x9E\xAB\xE5\xD7\xEA\xDB\x1BV\x1F\x93\x7F\xF6\x91dsolcC\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\0\x85W_5`\xE0\x1C\x80c\xADt}\xE6\x11a\0XW\x80c\xADt}\xE6\x14a\x01)W\x80c\xB9\x93|\xCB\x14a\x01PW\x80c\xC8\xC7\xF7\x01\x14a\x01wW\x80c\xE3L\xEF\x86\x14a\x01\xACW__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0\x89W\x80cN=\xF3\xF4\x14a\0\xDAW\x80cPcL\x0E\x14a\x01\x01W\x80c\x7F\x81O5\x14a\x01\x16W[__\xFD[a\0\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\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\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\x81V[a\x01\x14a\x01\x0F6`\x04a\x0BgV[a\x01\xD3V[\0[a\x01\x14a\x01$6`\x04a\x0C)V[a\x01\xFDV[a\0\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\x81V[a\0\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\x81V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xD1V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\xE8\x91\x90a\x0C\xADV[\x90Pa\x01\xF6\x85\x85\x85\x84a\x01\xFDV[PPPPPV[a\x02\x1Fs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x9AV[a\x02`s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x036\x91\x90a\x0C\xD1V[\x90Pa\x03\x99s\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\x7F\0\0\0\0\0\0\0\0\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\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x82\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04KW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04o\x91\x90a\x0C\xD1V[\x83Q\x90\x91P\x81\x10\x15a\x04\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[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\x85\x83a\x07YV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x06X\x90\x85\x90\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\x90`\x84\x01[`@\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\x07\xB4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF6\x91\x90a\x0C\xD1V[a\x07\0\x91\x90a\x0C\xE8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x06X\x90\x85\x90\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\x90`d\x01a\x05\xF4V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07\xAF\x90\x84\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\x90`d\x01a\x05\xF4V[PPPV[_a\x08\x15\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\x08\xBF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\xAFW\x80\x80` \x01\x90Q\x81\x01\x90a\x083\x91\x90a\r&V[a\x07\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\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\x04\xD9V[``a\x08\xCD\x84\x84_\x85a\x08\xD7V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\tiW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x04\xD9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\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`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x04\xD9V[__\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\n\x0F\x91\x90a\rEV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\nIW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\nNV[``\x91P[P\x91P\x91Pa\n^\x82\x82\x86a\niV[\x97\x96PPPPPPPV[``\x83\x15a\nxWP\x81a\x08\xD0V[\x82Q\x15a\n\x88W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x04\xD9\x91\x90a\r[V[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\xDDW__\xFD[PV[\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\x0B0Wa\x0B0a\n\xE0V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0B_Wa\x0B_a\n\xE0V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0BzW__\xFD[\x845a\x0B\x85\x81a\n\xBCV[\x93P` \x85\x015\x92P`@\x85\x015a\x0B\x9C\x81a\n\xBCV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xB7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\x0B\xC7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xE1Wa\x0B\xE1a\n\xE0V[a\x0B\xF4` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0B6V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0C\x08W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0C=W__\xFD[\x855a\x0CH\x81a\n\xBCV[\x94P` \x86\x015\x93P`@\x86\x015a\x0C_\x81a\n\xBCV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0C\x90W__\xFD[Pa\x0C\x99a\x0B\rV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0C\xBEW__\xFD[Pa\x0C\xC7a\x0B\rV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C\xE1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\r 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[_` \x82\x84\x03\x12\x15a\r6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x08\xD0W__\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\xFE\xA2dipfsX\"\x12 \xD28\x8C\xB3\xDCz\xA6\xF5\xA2\xEBuA}\x11\x05\x9B\xE1<\x8C\x9E\xAB\xE5\xD7\xEA\xDB\x1BV\x1F\x93\x7F\xF6\x91dsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**```solidity +struct StrategySlippageArgs { uint256 amountOutMin; } +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct StrategySlippageArgs { + #[allow(missing_docs)] + pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: StrategySlippageArgs) -> Self { + (value.amountOutMin,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for StrategySlippageArgs { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { amountOutMin: tuple.0 } + } + } + #[automatically_derived] + impl alloy_sol_types::SolValue for StrategySlippageArgs { + type SolType = Self; + } + #[automatically_derived] + impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { + #[inline] + fn stv_to_tokens(&self) -> ::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), + ) + } + #[inline] + fn stv_abi_encoded_size(&self) -> usize { + if let Some(size) = ::ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + } + #[inline] + fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { + ::eip712_hash_struct(self) + } + #[inline] + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) + } + #[inline] + fn stv_abi_packed_encoded_size(&self) -> usize { + if let Some(size) = ::PACKED_ENCODED_SIZE { + return size; + } + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolType for StrategySlippageArgs { + type RustType = Self; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SOL_NAME: &'static str = ::NAME; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + #[inline] + fn valid_token(token: &Self::Token<'_>) -> bool { + as alloy_sol_types::SolType>::valid_token(token) + } + #[inline] + fn detokenize(token: Self::Token<'_>) -> Self::RustType { + let tuple = as alloy_sol_types::SolType>::detokenize(token); + >>::from(tuple) + } + } + #[automatically_derived] + impl alloy_sol_types::SolStruct for StrategySlippageArgs { + const NAME: &'static str = "StrategySlippageArgs"; + #[inline] + fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { + alloy_sol_types::private::Cow::Borrowed( + "StrategySlippageArgs(uint256 amountOutMin)", + ) + } + #[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> { + ::eip712_root_type() + } + #[inline] + fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { + as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) + .0 + .to_vec() + } + } + #[automatically_derived] + impl alloy_sol_types::EventTopic for StrategySlippageArgs { + #[inline] + fn topic_preimage_length(rust: &Self::RustType) -> usize { + 0usize + + as alloy_sol_types::EventTopic>::topic_preimage_length( + &rust.amountOutMin, + ) + } + #[inline] + fn encode_topic_preimage( + rust: &Self::RustType, + out: &mut alloy_sol_types::private::Vec, + ) { + out.reserve( + ::topic_preimage_length(rust), + ); + as alloy_sol_types::EventTopic>::encode_topic_preimage( + &rust.amountOutMin, + out, + ); + } + #[inline] + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + let mut out = alloy_sol_types::private::Vec::new(); + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. +```solidity +event TokenOutput(address tokenReceived, uint256 amountOut); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct TokenOutput { + #[allow(missing_docs)] + pub tokenReceived: alloy::sol_types::private::Address, + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for TokenOutput { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + tokenReceived: data.0, + amountOut: data.1, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.tokenReceived, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountOut), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 TokenOutput { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&TokenOutput> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + /**Constructor`. +```solidity +constructor(address _solvBTCRouter, address _solvLSTRouter, bytes32 _solvBTCPoolId, bytes32 _solvLSTPoolId, address _solvBTC, address _solvLST); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct constructorCall { + #[allow(missing_docs)] + pub _solvBTCRouter: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _solvLSTRouter: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _solvBTCPoolId: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub _solvLSTPoolId: alloy::sol_types::private::FixedBytes<32>, + #[allow(missing_docs)] + pub _solvBTC: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub _solvLST: alloy::sol_types::private::Address, + } + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + 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, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::Address, + alloy::sol_types::private::FixedBytes<32>, + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: constructorCall) -> Self { + ( + value._solvBTCRouter, + value._solvLSTRouter, + value._solvBTCPoolId, + value._solvLSTPoolId, + value._solvBTC, + value._solvLST, + ) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for constructorCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + _solvBTCRouter: tuple.0, + _solvLSTRouter: tuple.1, + _solvBTCPoolId: tuple.2, + _solvLSTPoolId: tuple.3, + _solvBTC: tuple.4, + _solvLST: tuple.5, + } + } + } + } + #[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::FixedBytes<32>, + alloy::sol_types::sol_data::FixedBytes<32>, + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Address, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self._solvBTCRouter, + ), + ::tokenize( + &self._solvLSTRouter, + ), + as alloy_sol_types::SolType>::tokenize(&self._solvBTCPoolId), + as alloy_sol_types::SolType>::tokenize(&self._solvLSTPoolId), + ::tokenize( + &self._solvBTC, + ), + ::tokenize( + &self._solvLST, + ), + ) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. +```solidity +function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub message: alloy::sol_types::private::Bytes, + } + ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + 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, + ); + #[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, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.message) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + message: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageCall { + 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, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; + const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.message, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. +```solidity +function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsCall { + #[allow(missing_docs)] + pub tokenSent: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amountIn: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub recipient: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub args: ::RustType, + } + ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct handleGatewayMessageWithSlippageArgsReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Address, + alloy::sol_types::private::primitives::aliases::U256, + alloy::sol_types::private::Address, + ::RustType, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { + (value.tokenSent, value.amountIn, value.recipient, value.args) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + tokenSent: tuple.0, + amountIn: tuple.1, + recipient: tuple.2, + args: tuple.3, + } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for handleGatewayMessageWithSlippageArgsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl handleGatewayMessageWithSlippageArgsReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { + type Parameters<'a> = ( + alloy::sol_types::sol_data::Address, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Address, + StrategySlippageArgs, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = handleGatewayMessageWithSlippageArgsReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; + const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + ::tokenize( + &self.tokenSent, + ), + as alloy_sol_types::SolType>::tokenize(&self.amountIn), + ::tokenize( + &self.recipient, + ), + ::tokenize( + &self.args, + ), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `solvBTC()` and selector `0xb9937ccb`. +```solidity +function solvBTC() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct solvBTCCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`solvBTC()`](solvBTCCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct solvBTCReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: solvBTCCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for solvBTCCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: solvBTCReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for solvBTCReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for solvBTCCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "solvBTC()"; + const SELECTOR: [u8; 4] = [185u8, 147u8, 124u8, 203u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: solvBTCReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: solvBTCReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `solvBTCPoolId()` and selector `0xc8c7f701`. +```solidity +function solvBTCPoolId() external view returns (bytes32); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct solvBTCPoolIdCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`solvBTCPoolId()`](solvBTCPoolIdCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct solvBTCPoolIdReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: solvBTCPoolIdCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for solvBTCPoolIdCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: solvBTCPoolIdReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for solvBTCPoolIdReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for solvBTCPoolIdCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::FixedBytes<32>; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "solvBTCPoolId()"; + const SELECTOR: [u8; 4] = [200u8, 199u8, 247u8, 1u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: solvBTCPoolIdReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: solvBTCPoolIdReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `solvBTCRouter()` and selector `0x06af019a`. +```solidity +function solvBTCRouter() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct solvBTCRouterCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`solvBTCRouter()`](solvBTCRouterCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct solvBTCRouterReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: solvBTCRouterCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for solvBTCRouterCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: solvBTCRouterReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for solvBTCRouterReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for solvBTCRouterCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "solvBTCRouter()"; + const SELECTOR: [u8; 4] = [6u8, 175u8, 1u8, 154u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: solvBTCRouterReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: solvBTCRouterReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `solvLST()` and selector `0xad747de6`. +```solidity +function solvLST() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct solvLSTCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`solvLST()`](solvLSTCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct solvLSTReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: solvLSTCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for solvLSTCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: solvLSTReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for solvLSTReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for solvLSTCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "solvLST()"; + const SELECTOR: [u8; 4] = [173u8, 116u8, 125u8, 230u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: solvLSTReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: solvLSTReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `solvLSTPoolId()` and selector `0xe34cef86`. +```solidity +function solvLSTPoolId() external view returns (bytes32); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct solvLSTPoolIdCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`solvLSTPoolId()`](solvLSTPoolIdCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct solvLSTPoolIdReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: solvLSTPoolIdCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for solvLSTPoolIdCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: solvLSTPoolIdReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for solvLSTPoolIdReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for solvLSTPoolIdCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::FixedBytes<32>; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "solvLSTPoolId()"; + const SELECTOR: [u8; 4] = [227u8, 76u8, 239u8, 134u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: solvLSTPoolIdReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: solvLSTPoolIdReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `solvLSTRouter()` and selector `0x4e3df3f4`. +```solidity +function solvLSTRouter() external view returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct solvLSTRouterCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`solvLSTRouter()`](solvLSTRouterCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct solvLSTRouterReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: solvLSTRouterCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for solvLSTRouterCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: solvLSTRouterReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for solvLSTRouterReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for solvLSTRouterCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "solvLSTRouter()"; + const SELECTOR: [u8; 4] = [78u8, 61u8, 243u8, 244u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: solvLSTRouterReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: solvLSTRouterReturn = r.into(); + r._0 + }) + } + } + }; + ///Container for all the [`SolvLSTStrategy`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum SolvLSTStrategyCalls { + #[allow(missing_docs)] + handleGatewayMessage(handleGatewayMessageCall), + #[allow(missing_docs)] + handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), + #[allow(missing_docs)] + solvBTC(solvBTCCall), + #[allow(missing_docs)] + solvBTCPoolId(solvBTCPoolIdCall), + #[allow(missing_docs)] + solvBTCRouter(solvBTCRouterCall), + #[allow(missing_docs)] + solvLST(solvLSTCall), + #[allow(missing_docs)] + solvLSTPoolId(solvLSTPoolIdCall), + #[allow(missing_docs)] + solvLSTRouter(solvLSTRouterCall), + } + #[automatically_derived] + impl SolvLSTStrategyCalls { + /// 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, 175u8, 1u8, 154u8], + [78u8, 61u8, 243u8, 244u8], + [80u8, 99u8, 76u8, 14u8], + [127u8, 129u8, 79u8, 53u8], + [173u8, 116u8, 125u8, 230u8], + [185u8, 147u8, 124u8, 203u8], + [200u8, 199u8, 247u8, 1u8], + [227u8, 76u8, 239u8, 134u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for SolvLSTStrategyCalls { + const NAME: &'static str = "SolvLSTStrategyCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 8usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::handleGatewayMessage(_) => { + ::SELECTOR + } + Self::handleGatewayMessageWithSlippageArgs(_) => { + ::SELECTOR + } + Self::solvBTC(_) => ::SELECTOR, + Self::solvBTCPoolId(_) => { + ::SELECTOR + } + Self::solvBTCRouter(_) => { + ::SELECTOR + } + Self::solvLST(_) => ::SELECTOR, + Self::solvLSTPoolId(_) => { + ::SELECTOR + } + Self::solvLSTRouter(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn solvBTCRouter( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SolvLSTStrategyCalls::solvBTCRouter) + } + solvBTCRouter + }, + { + fn solvLSTRouter( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SolvLSTStrategyCalls::solvLSTRouter) + } + solvLSTRouter + }, + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SolvLSTStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map( + SolvLSTStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + { + fn solvLST( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(SolvLSTStrategyCalls::solvLST) + } + solvLST + }, + { + fn solvBTC( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(SolvLSTStrategyCalls::solvBTC) + } + solvBTC + }, + { + fn solvBTCPoolId( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SolvLSTStrategyCalls::solvBTCPoolId) + } + solvBTCPoolId + }, + { + fn solvLSTPoolId( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SolvLSTStrategyCalls::solvLSTPoolId) + } + solvLSTPoolId + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn solvBTCRouter( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SolvLSTStrategyCalls::solvBTCRouter) + } + solvBTCRouter + }, + { + fn solvLSTRouter( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SolvLSTStrategyCalls::solvLSTRouter) + } + solvLSTRouter + }, + { + fn handleGatewayMessage( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SolvLSTStrategyCalls::handleGatewayMessage) + } + handleGatewayMessage + }, + { + fn handleGatewayMessageWithSlippageArgs( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map( + SolvLSTStrategyCalls::handleGatewayMessageWithSlippageArgs, + ) + } + handleGatewayMessageWithSlippageArgs + }, + { + fn solvLST( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SolvLSTStrategyCalls::solvLST) + } + solvLST + }, + { + fn solvBTC( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SolvLSTStrategyCalls::solvBTC) + } + solvBTC + }, + { + fn solvBTCPoolId( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SolvLSTStrategyCalls::solvBTCPoolId) + } + solvBTCPoolId + }, + { + fn solvLSTPoolId( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SolvLSTStrategyCalls::solvLSTPoolId) + } + solvLSTPoolId + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::handleGatewayMessage(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::solvBTC(inner) => { + ::abi_encoded_size(inner) + } + Self::solvBTCPoolId(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::solvBTCRouter(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::solvLST(inner) => { + ::abi_encoded_size(inner) + } + Self::solvLSTPoolId(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::solvLSTRouter(inner) => { + ::abi_encoded_size( + inner, + ) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::handleGatewayMessage(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::handleGatewayMessageWithSlippageArgs(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::solvBTC(inner) => { + ::abi_encode_raw(inner, out) + } + Self::solvBTCPoolId(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::solvBTCRouter(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::solvLST(inner) => { + ::abi_encode_raw(inner, out) + } + Self::solvLSTPoolId(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::solvLSTRouter(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`SolvLSTStrategy`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum SolvLSTStrategyEvents { + #[allow(missing_docs)] + TokenOutput(TokenOutput), + } + #[automatically_derived] + impl SolvLSTStrategyEvents { + /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, + 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, + 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for SolvLSTStrategyEvents { + const NAME: &'static str = "SolvLSTStrategyEvents"; + const COUNT: usize = 1usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::TokenOutput) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 SolvLSTStrategyEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::TokenOutput(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`SolvLSTStrategy`](self) contract instance. + +See the [wrapper's documentation](`SolvLSTStrategyInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> SolvLSTStrategyInstance { + SolvLSTStrategyInstance::::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: alloy_contract::private::Network, + >( + provider: P, + _solvBTCRouter: alloy::sol_types::private::Address, + _solvLSTRouter: alloy::sol_types::private::Address, + _solvBTCPoolId: alloy::sol_types::private::FixedBytes<32>, + _solvLSTPoolId: alloy::sol_types::private::FixedBytes<32>, + _solvBTC: alloy::sol_types::private::Address, + _solvLST: alloy::sol_types::private::Address, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + SolvLSTStrategyInstance::< + P, + N, + >::deploy( + provider, + _solvBTCRouter, + _solvLSTRouter, + _solvBTCPoolId, + _solvLSTPoolId, + _solvBTC, + _solvLST, + ) + } + /**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: alloy_contract::private::Network, + >( + provider: P, + _solvBTCRouter: alloy::sol_types::private::Address, + _solvLSTRouter: alloy::sol_types::private::Address, + _solvBTCPoolId: alloy::sol_types::private::FixedBytes<32>, + _solvLSTPoolId: alloy::sol_types::private::FixedBytes<32>, + _solvBTC: alloy::sol_types::private::Address, + _solvLST: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + SolvLSTStrategyInstance::< + P, + N, + >::deploy_builder( + provider, + _solvBTCRouter, + _solvLSTRouter, + _solvBTCPoolId, + _solvLSTPoolId, + _solvBTC, + _solvLST, + ) + } + /**A [`SolvLSTStrategy`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`SolvLSTStrategy`](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 SolvLSTStrategyInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for SolvLSTStrategyInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("SolvLSTStrategyInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SolvLSTStrategyInstance { + /**Creates a new wrapper around an on-chain [`SolvLSTStrategy`](self) contract instance. + +See the [wrapper's documentation](`SolvLSTStrategyInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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, + _solvBTCRouter: alloy::sol_types::private::Address, + _solvLSTRouter: alloy::sol_types::private::Address, + _solvBTCPoolId: alloy::sol_types::private::FixedBytes<32>, + _solvLSTPoolId: alloy::sol_types::private::FixedBytes<32>, + _solvBTC: alloy::sol_types::private::Address, + _solvLST: alloy::sol_types::private::Address, + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder( + provider, + _solvBTCRouter, + _solvLSTRouter, + _solvBTCPoolId, + _solvLSTPoolId, + _solvBTC, + _solvLST, + ); + 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, + _solvBTCRouter: alloy::sol_types::private::Address, + _solvLSTRouter: alloy::sol_types::private::Address, + _solvBTCPoolId: alloy::sol_types::private::FixedBytes<32>, + _solvLSTPoolId: alloy::sol_types::private::FixedBytes<32>, + _solvBTC: alloy::sol_types::private::Address, + _solvLST: alloy::sol_types::private::Address, + ) -> alloy_contract::RawCallBuilder { + alloy_contract::RawCallBuilder::new_raw_deploy( + provider, + [ + &BYTECODE[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + _solvBTCRouter, + _solvLSTRouter, + _solvBTCPoolId, + _solvLSTPoolId, + _solvBTC, + _solvLST, + }, + )[..], + ] + .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 SolvLSTStrategyInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> SolvLSTStrategyInstance { + SolvLSTStrategyInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SolvLSTStrategyInstance { + /// 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( + &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 [`handleGatewayMessage`] function. + pub fn handleGatewayMessage( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + message: alloy::sol_types::private::Bytes, + ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { + self.call_builder( + &handleGatewayMessageCall { + tokenSent, + amountIn, + recipient, + message, + }, + ) + } + ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. + pub fn handleGatewayMessageWithSlippageArgs( + &self, + tokenSent: alloy::sol_types::private::Address, + amountIn: alloy::sol_types::private::primitives::aliases::U256, + recipient: alloy::sol_types::private::Address, + args: ::RustType, + ) -> alloy_contract::SolCallBuilder< + &P, + handleGatewayMessageWithSlippageArgsCall, + N, + > { + self.call_builder( + &handleGatewayMessageWithSlippageArgsCall { + tokenSent, + amountIn, + recipient, + args, + }, + ) + } + ///Creates a new call builder for the [`solvBTC`] function. + pub fn solvBTC(&self) -> alloy_contract::SolCallBuilder<&P, solvBTCCall, N> { + self.call_builder(&solvBTCCall) + } + ///Creates a new call builder for the [`solvBTCPoolId`] function. + pub fn solvBTCPoolId( + &self, + ) -> alloy_contract::SolCallBuilder<&P, solvBTCPoolIdCall, N> { + self.call_builder(&solvBTCPoolIdCall) + } + ///Creates a new call builder for the [`solvBTCRouter`] function. + pub fn solvBTCRouter( + &self, + ) -> alloy_contract::SolCallBuilder<&P, solvBTCRouterCall, N> { + self.call_builder(&solvBTCRouterCall) + } + ///Creates a new call builder for the [`solvLST`] function. + pub fn solvLST(&self) -> alloy_contract::SolCallBuilder<&P, solvLSTCall, N> { + self.call_builder(&solvLSTCall) + } + ///Creates a new call builder for the [`solvLSTPoolId`] function. + pub fn solvLSTPoolId( + &self, + ) -> alloy_contract::SolCallBuilder<&P, solvLSTPoolIdCall, N> { + self.call_builder(&solvLSTPoolIdCall) + } + ///Creates a new call builder for the [`solvLSTRouter`] function. + pub fn solvLSTRouter( + &self, + ) -> alloy_contract::SolCallBuilder<&P, solvLSTRouterCall, N> { + self.call_builder(&solvLSTRouterCall) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > SolvLSTStrategyInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`TokenOutput`] event. + pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/fullrelaytestutils.rs b/crates/bindings/src/solv_strategy_forked.rs similarity index 67% rename from crates/bindings/src/fullrelaytestutils.rs rename to crates/bindings/src/solv_strategy_forked.rs index a1986e48f..66be6dd68 100644 --- a/crates/bindings/src/fullrelaytestutils.rs +++ b/crates/bindings/src/solv_strategy_forked.rs @@ -837,7 +837,7 @@ library StdInvariant { } } -interface FullRelayTestUtils { +interface SolvStrategyForked { event log(string); event log_address(address); event log_array(uint256[] val); @@ -861,56 +861,29 @@ interface FullRelayTestUtils { event log_uint(uint256); event logs(bytes); - constructor(string testFileName, string genesisHexPath, string genesisHeightPath, string periodStartPath); - function IS_TEST() external view returns (bool); function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); function excludeContracts() external view returns (address[] memory excludedContracts_); function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); function excludeSenders() external view returns (address[] memory excludedSenders_); function failed() external view returns (bool); - function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); - function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); - function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); - function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); + function setUp() external; + function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); function targetArtifacts() external view returns (string[] memory targetedArtifacts_); function targetContracts() external view returns (address[] memory targetedContracts_); function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); function targetSenders() external view returns (address[] memory targetedSenders_); + function testSolvBTCStrategy() external; + function testSolvLSTStrategy() external; + function token() external view returns (address); } ``` ...which was generated by the following JSON ABI: ```json [ - { - "type": "constructor", - "inputs": [ - { - "name": "testFileName", - "type": "string", - "internalType": "string" - }, - { - "name": "genesisHexPath", - "type": "string", - "internalType": "string" - }, - { - "name": "genesisHeightPath", - "type": "string", - "internalType": "string" - }, - { - "name": "periodStartPath", - "type": "string", - "internalType": "string" - } - ], - "stateMutability": "nonpayable" - }, { "type": "function", "name": "IS_TEST", @@ -1003,119 +976,38 @@ interface FullRelayTestUtils { }, { "type": "function", - "name": "getBlockHeights", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getDigestLes", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes32[]", - "internalType": "bytes32[]" - } - ], - "stateMutability": "view" + "name": "setUp", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" }, { "type": "function", - "name": "getHeaderHexes", + "name": "simulateForkAndTransfer", "inputs": [ { - "name": "chainName", - "type": "string", - "internalType": "string" - }, - { - "name": "from", + "name": "forkAtBlock", "type": "uint256", "internalType": "uint256" }, { - "name": "to", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "elements", - "type": "bytes[]", - "internalType": "bytes[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getHeaders", - "inputs": [ - { - "name": "chainName", - "type": "string", - "internalType": "string" + "name": "sender", + "type": "address", + "internalType": "address" }, { - "name": "from", - "type": "uint256", - "internalType": "uint256" + "name": "receiver", + "type": "address", + "internalType": "address" }, { - "name": "to", + "name": "amount", "type": "uint256", "internalType": "uint256" } ], - "outputs": [ - { - "name": "headers", - "type": "bytes", - "internalType": "bytes" - } - ], - "stateMutability": "view" + "outputs": [], + "stateMutability": "nonpayable" }, { "type": "function", @@ -1231,6 +1123,33 @@ interface FullRelayTestUtils { ], "stateMutability": "view" }, + { + "type": "function", + "name": "testSolvBTCStrategy", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "testSolvLSTStrategy", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "token", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IERC20" + } + ], + "stateMutability": "view" + }, { "type": "event", "name": "log", @@ -1604,28 +1523,28 @@ interface FullRelayTestUtils { clippy::style, clippy::empty_structs_with_brackets )] -pub mod FullRelayTestUtils { +pub mod SolvStrategyForked { use super::*; use alloy::sol_types as alloy_sol_types; /// 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`@R`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15a\0,W__\xFD[P`@QaL\xD78\x03\x80aL\xD7\x839\x81\x01`@\x81\x90Ra\0K\x91a\x05]V[__Q` aL\xB7_9_Q\x90_R`\x01`\x01`\xA0\x1B\x03\x16c\xD90\xA0\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\0\x94W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\0\xBB\x91\x90\x81\x01\x90a\x06\x18V[\x90P_\x81\x86`@Q` \x01a\0\xD1\x92\x91\x90a\x06hV[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Rc`\xF9\xBB\x11`\xE0\x1B\x82R\x91P_Q` aL\xB7_9_Q\x90_R\x90c`\xF9\xBB\x11\x90a\x01\x11\x90\x84\x90`\x04\x01a\x06\xDAV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01+W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x01R\x91\x90\x81\x01\x90a\x06\x18V[` \x90a\x01_\x90\x82a\x07pV[Pa\x01\xF6\x85` \x80Ta\x01q\x90a\x06\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x01\x9D\x90a\x06\xECV[\x80\x15a\x01\xE8W\x80`\x1F\x10a\x01\xBFWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x01\xE8V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x01\xCBW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x03\x85\x91PPV[a\x02\x8C\x85` \x80Ta\x02\x07\x90a\x06\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x023\x90a\x06\xECV[\x80\x15a\x02~W\x80`\x1F\x10a\x02UWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02~V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02aW\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x04\x02\x91PPV[a\x03\"\x85` \x80Ta\x02\x9D\x90a\x06\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\xC9\x90a\x06\xECV[\x80\x15a\x03\x14W\x80`\x1F\x10a\x02\xEBWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\x14V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02\xF7W\x82\x90\x03`\x1F\x16\x82\x01\x91[P\x93\x94\x93PPa\x04u\x91PPV[`@Qa\x03.\x90a\x04\xA9V[a\x03:\x93\x92\x91\x90a\x08*V[`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03SW=__>=_\xFD[P`\x1F`\x01a\x01\0\n\x81T\x81`\x01`\x01`\xA0\x1B\x03\x02\x19\x16\x90\x83`\x01`\x01`\xA0\x1B\x03\x16\x02\x17\x90UPPPPPPPa\x08\xCDV[`@Qc\x1F\xB2C}`\xE3\x1B\x81R``\x90_Q` aL\xB7_9_Q\x90_R\x90c\xFD\x92\x1B\xE8\x90a\x03\xBA\x90\x86\x90\x86\x90`\x04\x01a\x08NV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\xD4W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x03\xFB\x91\x90\x81\x01\x90a\x08rV[\x93\x92PPPV[`@QcV\xEE\xF1[`\xE1\x1B\x81R_\x90_Q` aL\xB7_9_Q\x90_R\x90c\xAD\xDD\xE2\xB6\x90a\x046\x90\x86\x90\x86\x90`\x04\x01a\x08NV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04QW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xFB\x91\x90a\x08\xB6V[`@Qc\x17w\xE5\x9D`\xE0\x1B\x81R_\x90_Q` aL\xB7_9_Q\x90_R\x90c\x17w\xE5\x9D\x90a\x046\x90\x86\x90\x86\x90`\x04\x01a\x08NV[a);\x80a#|\x839\x01\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x80`\x01`\x01`@\x1B\x03\x84\x11\x15a\x04\xE3Wa\x04\xE3a\x04\xB6V[P`@Q`\x1F\x19`\x1F\x85\x01\x81\x16`?\x01\x16\x81\x01\x81\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17\x15a\x05\x11Wa\x05\x11a\x04\xB6V[`@R\x83\x81R\x90P\x80\x82\x84\x01\x85\x10\x15a\x05(W__\xFD[\x83\x83` \x83\x01^_` \x85\x83\x01\x01RP\x93\x92PPPV[_\x82`\x1F\x83\x01\x12a\x05NW__\xFD[a\x03\xFB\x83\x83Q` \x85\x01a\x04\xCAV[____`\x80\x85\x87\x03\x12\x15a\x05pW__\xFD[\x84Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x05\x85W__\xFD[a\x05\x91\x87\x82\x88\x01a\x05?V[` \x87\x01Q\x90\x95P\x90P`\x01`\x01`@\x1B\x03\x81\x11\x15a\x05\xAEW__\xFD[a\x05\xBA\x87\x82\x88\x01a\x05?V[`@\x87\x01Q\x90\x94P\x90P`\x01`\x01`@\x1B\x03\x81\x11\x15a\x05\xD7W__\xFD[a\x05\xE3\x87\x82\x88\x01a\x05?V[``\x87\x01Q\x90\x93P\x90P`\x01`\x01`@\x1B\x03\x81\x11\x15a\x06\0W__\xFD[a\x06\x0C\x87\x82\x88\x01a\x05?V[\x91PP\x92\x95\x91\x94P\x92PV[_` \x82\x84\x03\x12\x15a\x06(W__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x06=W__\xFD[a\x06I\x84\x82\x85\x01a\x05?V[\x94\x93PPPPV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x06s\x82\x85a\x06QV[\x7F/test/fullRelay/testData/\0\0\0\0\0\0\0\x81Ra\x06\xA3`\x19\x82\x01\x85a\x06QV[\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R_a\x03\xFB` \x83\x01\x84a\x06\xACV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x07\0W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x07\x1EWcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\x07kW\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x07IWP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x07hW_\x81U`\x01\x01a\x07UV[PP[PPPV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x07\x89Wa\x07\x89a\x04\xB6V[a\x07\x9D\x81a\x07\x97\x84Ta\x06\xECV[\x84a\x07$V[` `\x1F\x82\x11`\x01\x81\x14a\x07\xCFW_\x83\x15a\x07\xB8WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x07hV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x07\xFEW\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x07\xDEV[P\x84\x82\x10\x15a\x08\x1BW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[``\x81R_a\x08<``\x83\x01\x86a\x06\xACV[` \x83\x01\x94\x90\x94RP`@\x01R\x91\x90PV[`@\x81R_a\x08``@\x83\x01\x85a\x06\xACV[\x82\x81\x03` \x84\x01Ra\x06\xA3\x81\x85a\x06\xACV[_` \x82\x84\x03\x12\x15a\x08\x82W__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x08\x97W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x08\xA7W__\xFD[a\x06I\x84\x82Q` \x84\x01a\x04\xCAV[_` \x82\x84\x03\x12\x15a\x08\xC6W__\xFD[PQ\x91\x90PV[a\x1A\xA2\x80a\x08\xDA_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xFBW_5`\xE0\x1C\x80c\x85\"l\x81\x11a\0\x93W\x80c\xBAAO\xA6\x11a\0cW\x80c\xBAAO\xA6\x14a\x01\xF1W\x80c\xE2\x0C\x9Fq\x14a\x02\tW\x80c\xFAv&\xD4\x14a\x02\x11W\x80c\xFA\xD0k\x8F\x14a\x02\x1EW__\xFD[\x80c\x85\"l\x81\x14a\x01\xB7W\x80c\x91j\x17\xC6\x14a\x01\xCCW\x80c\xB0FO\xDC\x14a\x01\xE1W\x80c\xB5P\x8A\xA9\x14a\x01\xE9W__\xFD[\x80c>^<#\x11a\0\xCEW\x80c>^<#\x14a\x01rW\x80c?r\x86\xF4\x14a\x01zW\x80cD\xBA\xDB\xB6\x14a\x01\x82W\x80cf\xD9\xA9\xA0\x14a\x01\xA2W__\xFD[\x80c\x08\x13\x85*\x14a\0\xFFW\x80c\x1C\r\xA8\x1F\x14a\x01(W\x80c\x1E\xD7\x83\x1C\x14a\x01HW\x80c*\xDE8\x80\x14a\x01]W[__\xFD[a\x01\x12a\x01\r6`\x04a\x13\x89V[a\x021V[`@Qa\x01\x1F\x91\x90a\x14>V[`@Q\x80\x91\x03\x90\xF3[a\x01;a\x0166`\x04a\x13\x89V[a\x02|V[`@Qa\x01\x1F\x91\x90a\x14\xA1V[a\x01Pa\x02\xEEV[`@Qa\x01\x1F\x91\x90a\x14\xB3V[a\x01ea\x03[V[`@Qa\x01\x1F\x91\x90a\x15eV[a\x01Pa\x04\xA4V[a\x01Pa\x05\x0FV[a\x01\x95a\x01\x906`\x04a\x13\x89V[a\x05zV[`@Qa\x01\x1F\x91\x90a\x15\xE9V[a\x01\xAAa\x05\xBDV[`@Qa\x01\x1F\x91\x90a\x16|V[a\x01\xBFa\x076V[`@Qa\x01\x1F\x91\x90a\x16\xFAV[a\x01\xD4a\x08\x01V[`@Qa\x01\x1F\x91\x90a\x17\x0CV[a\x01\xD4a\t\x04V[a\x01\xBFa\n\x07V[a\x01\xF9a\n\xD2V[`@Q\x90\x15\x15\x81R` \x01a\x01\x1FV[a\x01Pa\x0B\xA2V[`\x1FTa\x01\xF9\x90`\xFF\x16\x81V[a\x01\x95a\x02,6`\x04a\x13\x89V[a\x0C\rV[``a\x02t\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x0CPV[\x94\x93PPPPV[``_a\x02\x8A\x85\x85\x85a\x021V[\x90P_[a\x02\x98\x85\x85a\x17\xBDV[\x81\x10\x15a\x02\xE5W\x82\x82\x82\x81Q\x81\x10a\x02\xB2Wa\x02\xB2a\x17\xD0V[` \x02` \x01\x01Q`@Q` \x01a\x02\xCB\x92\x91\x90a\x18\x14V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x02\x8EV[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03QW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03&W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\x84W\x83\x82\x90_R` _ \x01\x80Ta\x03\xF9\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x04%\x90a\x18(V[\x80\x15a\x04pW\x80`\x1F\x10a\x04GWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x04pV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x04SW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03\xDCV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x03~V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03QW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03&WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03QW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03&WPPPPP\x90P\x90V[``a\x02t\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\r\xB1V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x06\x10\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06<\x90a\x18(V[\x80\x15a\x06\x87W\x80`\x1F\x10a\x06^Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x06\x87V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x06jW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07\x1EW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x06\xCBW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05\xE0V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW\x83\x82\x90_R` _ \x01\x80Ta\x07v\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07\xA2\x90a\x18(V[\x80\x15a\x07\xEDW\x80`\x1F\x10a\x07\xC4Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07\xEDV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\xD0W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x07YV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x08\xECW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x08\x99W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x08$V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\t\xEFW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\t\x9CW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\t'V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW\x83\x82\x90_R` _ \x01\x80Ta\nG\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\ns\x90a\x18(V[\x80\x15a\n\xBEW\x80`\x1F\x10a\n\x95Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\xBEV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\n\xA1W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\n*V[`\x08T_\x90`\xFF\x16\x15a\n\xE9WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0BwW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\x9B\x91\x90a\x18yV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03QW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03&WPPPPP\x90P\x90V[``a\x02t\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x0E\xFFV[``a\x0C\\\x84\x84a\x17\xBDV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0CtWa\x0Cta\x13\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0C\xA7W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x0C\x92W\x90P[P\x90P\x83[\x83\x81\x10\x15a\r\xA8Wa\rz\x86a\x0C\xC1\x83a\x10MV[\x85`@Q` \x01a\x0C\xD4\x93\x92\x91\x90a\x18\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x0C\xF0\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\x1C\x90a\x18(V[\x80\x15a\rgW\x80`\x1F\x10a\r>Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rgV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\rJW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x11~\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\r\x85\x87\x84a\x17\xBDV[\x81Q\x81\x10a\r\x95Wa\r\x95a\x17\xD0V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x0C\xACV[P\x94\x93PPPPV[``a\r\xBD\x84\x84a\x17\xBDV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\xD5Wa\r\xD5a\x13\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\r\xFEW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\r\xA8Wa\x0E\xD1\x86a\x0E\x18\x83a\x10MV[\x85`@Q` \x01a\x0E+\x93\x92\x91\x90a\x18\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x0EG\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0Es\x90a\x18(V[\x80\x15a\x0E\xBEW\x80`\x1F\x10a\x0E\x95Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0E\xBEV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0E\xA1W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x12\x1D\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x0E\xDC\x87\x84a\x17\xBDV[\x81Q\x81\x10a\x0E\xECWa\x0E\xECa\x17\xD0V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x0E\x03V[``a\x0F\x0B\x84\x84a\x17\xBDV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0F#Wa\x0F#a\x13\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0FLW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\r\xA8Wa\x10\x1F\x86a\x0Ff\x83a\x10MV[\x85`@Q` \x01a\x0Fy\x93\x92\x91\x90a\x18\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x0F\x95\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F\xC1\x90a\x18(V[\x80\x15a\x10\x0CW\x80`\x1F\x10a\x0F\xE3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x10\x0CV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\xEFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x12\xB0\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x10*\x87\x84a\x17\xBDV[\x81Q\x81\x10a\x10:Wa\x10:a\x17\xD0V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x0FQV[``\x81_\x03a\x10\x8FWPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x10\xB8W\x80a\x10\xA2\x81a\x19-V[\x91Pa\x10\xB1\x90P`\n\x83a\x19\x91V[\x91Pa\x10\x92V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10\xD2Wa\x10\xD2a\x13\x04V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x10\xFCW` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x02tWa\x11\x11`\x01\x83a\x17\xBDV[\x91Pa\x11\x1E`\n\x86a\x19\xA4V[a\x11)\x90`0a\x19\xB7V[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x11>Wa\x11>a\x17\xD0V[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x11w`\n\x86a\x19\x91V[\x94Pa\x11\0V[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a\x11\xD3\x90\x86\x90\x86\x90`\x04\x01a\x19\xCAV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\xEDW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x12\x14\x91\x90\x81\x01\x90a\x19\xF7V[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x12q\x90\x86\x90\x86\x90`\x04\x01a\x19\xCAV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x12\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\x14\x91\x90a\x18yV[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x12q\x90\x86\x90\x86\x90`\x04\x01a\x19\xCAV[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x13ZWa\x13Za\x13\x04V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x13{Wa\x13{a\x13\x04V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x13\x9BW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x13\xB1W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x13\xC1W__\xFD[\x805a\x13\xD4a\x13\xCF\x82a\x13bV[a\x131V[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x13\xE8W__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\x95W`?\x19\x87\x86\x03\x01\x84Ra\x14\x80\x85\x83Qa\x14\x10V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14dV[P\x92\x96\x95PPPPPPV[` \x81R_a\x12\x14` \x83\x01\x84a\x14\x10V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x15\0W\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\x14\xCCV[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x15YW`\x1F\x19\x85\x84\x03\x01\x88Ra\x15C\x83\x83Qa\x14\x10V[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x15'V[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\x95W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x15\xD3`@\x87\x01\x82a\x15\x0BV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\x8BV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x15\0W\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x16\x02V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x16rW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x162V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\x95W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x16\xC8`@\x88\x01\x82a\x14\x10V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x16\xE3\x81\x83a\x16 V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16\xA2V[` \x81R_a\x12\x14` \x83\x01\x84a\x15\x0BV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\x95W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x17z`@\x87\x01\x82a\x16 V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x172V[\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\x12\x17Wa\x12\x17a\x17\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x02ta\x18\"\x83\x86a\x17\xFDV[\x84a\x17\xFDV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x18=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xB6\x91\x90a\x04NV[`@Q` \x01a\x01\xC8\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra\x01\xE2\x91a\x048V[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x01\xFDW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02 \x91\x90a\x04NV[\x92\x91PPV[_a\x02 a\x023\x83a\x028V[a\x02CV[_a\x02 \x82\x82a\x02SV[_a\x02 a\xFF\xFF`\xD0\x1B\x83a\x02\xF7V[_\x80a\x02ja\x02c\x84`Ha\x04eV[\x85\x90a\x03\tV[`\xE8\x1C\x90P_\x84a\x02|\x85`Ka\x04eV[\x81Q\x81\x10a\x02\x8CWa\x02\x8Ca\x04xV[\x01` \x01Q`\xF8\x1C\x90P_a\x02\xBE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x02\xD1`\x03\x84a\x04\x8CV[`\xFF\x16\x90Pa\x02\xE2\x81a\x01\0a\x05\x88V[a\x02\xEC\x90\x83a\x05\x93V[\x97\x96PPPPPPPV[_a\x03\x02\x82\x84a\x05\xAAV[\x93\x92PPPV[_a\x03\x02\x83\x83\x01` \x01Q\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[___``\x84\x86\x03\x12\x15a\x03=W__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03RW__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x03bW__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x03{Wa\x03{a\x03\x17V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x03\xA9Wa\x03\xA9a\x03\x17V[`@R\x81\x81R\x82\x82\x01` \x01\x88\x10\x15a\x03\xC0W__\xFD[\x81` \x84\x01` \x83\x01^_` \x92\x82\x01\x83\x01R\x90\x86\x01Q`@\x90\x96\x01Q\x90\x97\x95\x96P\x94\x93PPPPV[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD[_\x82a\x04\x0CWa\x04\x0Ca\x03\xEAV[P\x06\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[_\x82Q\x80` \x85\x01\x84^_\x92\x01\x91\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x04^W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02 Wa\x02 a\x04\x11V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x02 Wa\x02 a\x04\x11V[`\x01\x81[`\x01\x84\x11\x15a\x04\xE0W\x80\x85\x04\x81\x11\x15a\x04\xC4Wa\x04\xC4a\x04\x11V[`\x01\x84\x16\x15a\x04\xD2W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a\x04\xA9V[\x93P\x93\x91PPV[_\x82a\x04\xF6WP`\x01a\x02 V[\x81a\x05\x02WP_a\x02 V[\x81`\x01\x81\x14a\x05\x18W`\x02\x81\x14a\x05\"Wa\x05>V[`\x01\x91PPa\x02 V[`\xFF\x84\x11\x15a\x053Wa\x053a\x04\x11V[PP`\x01\x82\x1Ba\x02 V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a\x05aWP\x81\x81\na\x02 V[a\x05m_\x19\x84\x84a\x04\xA5V[\x80_\x19\x04\x82\x11\x15a\x05\x80Wa\x05\x80a\x04\x11V[\x02\x93\x92PPPV[_a\x03\x02\x83\x83a\x04\xE8V[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x02 Wa\x02 a\x04\x11V[_\x82a\x05\xB8Wa\x05\xB8a\x03\xEAV[P\x04\x90V[a#q\x80a\x05\xCA_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cp\xD5<\x18\x11a\0\xADW\x80c\xB9\x85b\x1A\x11a\0}W\x80c\xE3\xD8\xD8\xD8\x11a\0cW\x80c\xE3\xD8\xD8\xD8\x14a\x02\"W\x80c\xE4q\xE7,\x14a\x02)W\x80c\xF5\x8D\xB0o\x14a\x02=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x13\x91\x90a!WV[`@Q` \x01a\x0C%\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\x90\x82\x90Ra\x0C]\x91a!AV[` `@Q\x80\x83\x03\x81\x85Z\xFA\x15\x80\x15a\x0CxW=__>=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x07\x91\x90a!WV[_\x83\x85\x14\x80\x15a\x0C\xAAWP\x82\x85\x14[\x15a\x0C\xB7WP`\x01a\x04\xF1V[\x83\x83\x81\x81_[\x86\x81\x10\x15a\x0C\xFFW\x89\x83\x14a\x0C\xDEW_\x83\x81R`\x03` R`@\x90 T\x92\x94P[\x89\x82\x14a\x0C\xF7W_\x82\x81R`\x03` R`@\x90 T\x91\x93P[`\x01\x01a\x0C\xBDV[P\x82\x84\x03a\r\x13W_\x94PPPPPa\x04\xF1V[\x80\x82\x14a\r&W_\x94PPPPPa\x04\xF1V[P`\x01\x98\x97PPPPPPPPV[_\x82\x81[\x83\x81\x10\x15a\rYW_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\r9V[P\x80a\x05\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x10`$\x82\x01R\x7FUnknown ancestor\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x80\x82\x81[a\r\xB8`\x04`\x01a!\x9BV[c\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x0E\x0CW_\x82\x81R`\x04` R`@\x81 T\x93P\x83\x90\x03a\r\xF1W_\x91\x82R`\x03` R`@\x90\x91 T\x90a\x0E\x04V[a\r\xFB\x81\x84a!\xB7V[\x95\x94PPPPPV[`\x01\x01a\r\xACV[P`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FUnknown block\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_`P\x82Qa\x0B~\x91\x90a!.V[__a\x0Eo\x85a\x0B\xC3V[\x90P_a\x0E{\x82a\r\xA7V[\x90P_a\x0E\x87\x86a\x19\xE6V[\x90P\x84\x80a\x0E\x9CWP\x80a\x0E\x9A\x88a\x19\xE6V[\x14[a\x0F\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FUnexpected retarget on external `D\x82\x01R\x7Fcall\0\0\0\0\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\x03.V[\x85Q_\x90\x81\x90\x81[\x81\x81\x10\x15a\x12\x0EWa\x0F(`P\x82a!\xCAV[a\x0F3\x90`\x01a!\xB7V[a\x0F=\x90\x87a!\xB7V[\x93Pa\x0FK\x8A\x82`Pa\x19\xF1V[_\x81\x81R`\x03` R`@\x90 T\x90\x93Pa\x11!W\x84a\x10\xA1\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a\x10\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FHeader work is insufficient\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_\x83\x81R`\x03` R`@\x90 \x87\x90Ua\x11\n`\x04\x85a!.V[_\x03a\x11!W_\x83\x81R`\x04` R`@\x90 \x84\x90U[\x84a\x11,\x8B\x83a\x1A\x16V[\x14a\x11yW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FTarget changed unexpectedly\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[\x86a\x11\x84\x8B\x83a\x1A\xAFV[\x14a\x11\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FHeaders do not form a consistent`D\x82\x01R\x7F chain\0\0\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\x03.V[\x82\x96P`P\x81a\x12\x07\x91\x90a!\xB7V[\x90Pa\x0F\x15V[P\x81a\x12\x19\x8Ba\x0B\xC3V[`@Q\x7F\xF9\x0EO\x1D\x9C\xD0\xDDU\xE39A\x1C\xBC\x9B\x15$\x820|:#\xEDdq^J(X\xF6A\xA3\xF5\x90_\x90\xA3P`\x01\x99\x98PPPPPPPPPV[_a\x07\xE0\x82\x11\x15a\x12\xCAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FRequested limit is greater than `D\x82\x01R\x7F1 difficulty period\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x12\xD4\x84a\x0B\xC3V[\x90P_a\x12\xE0\x86a\x0B\xC3V[\x90P`\x01T\x81\x14a\x133W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FPassed in best is not best known`D\x82\x01R`d\x01a\x03.V[_\x82\x81R`\x03` R`@\x90 Ta\x13\x8DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FNew best is unknown\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x13\x9B\x87`\x01T\x84\x87a\x0C\x9BV[a\x14\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FAncestor must be heaviest common`D\x82\x01R\x7F ancestor\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\x03.V[\x81a\x14\x19\x88\x88\x88a\x17\x80V[\x14a\x14\x8CW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FNew best hash does not have more`D\x82\x01R\x7F work than previous\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[`\x01\x82\x90U`\x02\x87\x90U_a\x14\xA0\x86a\x1A\xC7V[\x90P`\x05T\x81\x14a\x14\xB1W`\x05\x81\x90U[\x87\x83\x83\x7F<\xC1=\xE6M\xF0\xF0#\x96&#\\Q\xA2\xDA%\x1B\xBC\x8C\x85fN\xCC\xE3\x92c\xDA>\xE0?`l`@Q`@Q\x80\x91\x03\x90\xA4P`\x01\x97\x96PPPPPPPV[__a\x15\x01a\x14\xFC\x86a\x0B\xC3V[a\r\xA7V[\x90P_a\x15\x10a\x14\xFC\x86a\x0B\xC3V[\x90Pa\x15\x1Ea\x07\xE0\x82a!.V[a\x07\xDF\x14a\x15\x94W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`=`$\x82\x01R\x7FMust provide the last header of `D\x82\x01R\x7Fthe closing difficulty period\0\0\0`d\x82\x01R`\x84\x01a\x03.V[a\x15\xA0\x82a\x07\xDFa!\xB7V[\x81\x14a\x16\x14W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`(`$\x82\x01R\x7FMust provide exactly 1 difficult`D\x82\x01R\x7Fy period\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\x03.V[a\x16\x1D\x85a\x1A\xC7V[a\x16&\x87a\x1A\xC7V[\x14a\x16\x99W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FPeriod header difficulties do no`D\x82\x01R\x7Ft match\0\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\x03.V[_a\x16\xA3\x85a\x19\xE6V[\x90P_a\x16\xD5a\x16\xB2\x89a\x19\xE6V[a\x16\xBB\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x16\xCA\x8Aa\x1A\xD9V[c\xFF\xFF\xFF\xFF\x16a\x1B\x0CV[\x90P\x81\x81\x83\x16\x14a\x17(W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FInvalid retarget provided\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03.V[_a\x172\x89a\x1A\xC7V[\x90P\x80`\x06T\x14\x15\x80\x15a\x17\\WPa\x07\xE0a\x17O`\x01Ta\r\xA7V[a\x17Y\x91\x90a!\xDDV[\x84\x11[\x15a\x17gW`\x06\x81\x90U[a\x17s\x88\x88`\x01a\x0EdV[\x99\x98PPPPPPPPPV[__a\x17\x8B\x85a\r\xA7V[\x90P_a\x17\x9Aa\x14\xFC\x86a\x0B\xC3V[\x90P_a\x17\xA9a\x14\xFC\x86a\x0B\xC3V[\x90P\x82\x82\x10\x15\x80\x15a\x17\xBBWP\x82\x81\x10\x15[a\x18-W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FA descendant height is below the`D\x82\x01R\x7F ancestor height\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x03.V[_a\x18:a\x07\xE0\x85a!.V[a\x18F\x85a\x07\xE0a!\xB7V[a\x18P\x91\x90a!\xDDV[\x90P\x80\x83\x10\x81\x83\x10\x81\x15\x82a\x18bWP\x80[\x15a\x18}Wa\x18p\x89a\x0B\xC3V[\x96PPPPPPPa\n\xA3V[\x81\x80\x15a\x18\x88WP\x80\x15[\x15a\x18\x96Wa\x18p\x88a\x0B\xC3V[\x81\x80\x15a\x18\xA0WP\x80[\x15a\x18\xC4W\x83\x85\x10\x15a\x18\xBBWa\x18\xB6\x88a\x0B\xC3V[a\x18pV[a\x18p\x89a\x0B\xC3V[a\x18\xCD\x88a\x1A\xC7V[a\x18\xD9a\x07\xE0\x86a!.V[a\x18\xE3\x91\x90a!\xF0V[a\x18\xEC\x8Aa\x1A\xC7V[a\x18\xF8a\x07\xE0\x88a!.V[a\x19\x02\x91\x90a!\xF0V[\x10\x15a\x18\xBBWa\x18p\x88a\x0B\xC3V[`\x07T_\x90`\xFF\x16\x15a\x19/WP`\x07Ta\x01\0\x90\x04`\xFF\x16a\n\xA3V[a\x19:\x84\x84\x84a\x1B\x94V[\x90Pa\n\xA3V[_` \x84Qa\x19P\x91\x90a!.V[\x15a\x19\\WP_a\x04\xF1V[\x83Q_\x03a\x19kWP_a\x04\xF1V[\x81\x85_[\x86Q\x81\x10\x15a\x19\xD9Wa\x19\x83`\x02\x84a!.V[`\x01\x03a\x19\xA7Wa\x19\xA0a\x19\x9A\x88\x83\x01` \x01Q\x90V[\x83a\x1B\xD5V[\x91Pa\x19\xC0V[a\x19\xBD\x82a\x19\xB8\x89\x84\x01` \x01Q\x90V[a\x1B\xD5V[\x91P[`\x01\x92\x90\x92\x1C\x91a\x19\xD2` \x82a!\xB7V[\x90Pa\x19oV[P\x90\x93\x14\x95\x94PPPPPV[_a\x05\x07\x82_a\x1A\x16V[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x80a\x1A-a\x1A&\x84`Ha!\xB7V[\x85\x90a\x1B\xE0V[`\xE8\x1C\x90P_\x84a\x1A?\x85`Ka!\xB7V[\x81Q\x81\x10a\x1AOWa\x1AOa\"\x07V[\x01` \x01Q`\xF8\x1C\x90P_a\x1A\x81\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1A\x94`\x03\x84a\"4V[`\xFF\x16\x90Pa\x1A\xA5\x81a\x01\0a#0V[a\x08-\x90\x83a!\xF0V[_a\x05\x04a\x1A\xBE\x83`\x04a!\xB7V[\x84\x01` \x01Q\x90V[_a\x05\x07a\x1A\xD4\x83a\x19\xE6V[a\x1B\xEEV[_a\x05\x07a\x1A\xE6\x83a\x1C\x15V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80a\x1B\x18\x83\x85a\x1C!V[\x90Pa\x1B(b\x12u\0`\x04a\x1C|V[\x81\x10\x15a\x1B@Wa\x1B=b\x12u\0`\x04a\x1C|V[\x90P[a\x1BNb\x12u\0`\x04a\x1C\x87V[\x81\x11\x15a\x1BfWa\x1Bcb\x12u\0`\x04a\x1C\x87V[\x90P[_a\x1B~\x82a\x1Bx\x88b\x01\0\0a\x1C|V[\x90a\x1C\x87V[\x90Pa\n\x8Ab\x01\0\0a\x1Bx\x83b\x12u\0a\x1C|V[_\x82\x81[\x83\x81\x10\x15a\x1B\xCAW\x85\x82\x03a\x1B\xB2W`\x01\x92PPPa\n\xA3V[_\x91\x82R`\x03` R`@\x90\x91 T\x90`\x01\x01a\x1B\x98V[P_\x95\x94PPPPPV[_a\x05\x04\x83\x83a\x1C\xFAV[_a\x05\x04\x83\x83\x01` \x01Q\x90V[_a\x05\x07{\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\x83a\x1C|V[_a\x05\x07\x82`Da\x1B\xE0V[_\x82\x82\x11\x15a\x1CrW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x03.V[a\x05\x04\x82\x84a!\xDDV[_a\x05\x04\x82\x84a!\xCAV[_\x82_\x03a\x1C\x96WP_a\x05\x07V[a\x1C\xA0\x82\x84a!\xF0V[\x90P\x81a\x1C\xAD\x84\x83a!\xCAV[\x14a\x05\x07W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x03.V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[__\x83`\x1F\x84\x01\x12a\x1D1W__\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1DHW__\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x1D_W__\xFD[\x92P\x92\x90PV[\x805`\xFF\x81\x16\x81\x14a\x1DvW__\xFD[\x91\x90PV[_______`\xA0\x88\x8A\x03\x12\x15a\x1D\x91W__\xFD[\x875g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xA7W__\xFD[a\x1D\xB3\x8A\x82\x8B\x01a\x1D!V[\x90\x98P\x96PP` \x88\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1D\xD2W__\xFD[a\x1D\xDE\x8A\x82\x8B\x01a\x1D!V[\x90\x96P\x94PP`@\x88\x015\x92P``\x88\x015\x91Pa\x1D\xFE`\x80\x89\x01a\x1DfV[\x90P\x92\x95\x98\x91\x94\x97P\x92\x95PV[____`\x80\x85\x87\x03\x12\x15a\x1E\x1FW__\xFD[PP\x825\x94` \x84\x015\x94P`@\x84\x015\x93``\x015\x92P\x90PV[__`@\x83\x85\x03\x12\x15a\x1ELW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x1EkW__\xFD[P5\x91\x90PV[____`@\x85\x87\x03\x12\x15a\x1E\x85W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\x9BW__\xFD[a\x1E\xA7\x87\x82\x88\x01a\x1D!V[\x90\x95P\x93PP` \x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1E\xC6W__\xFD[a\x1E\xD2\x87\x82\x88\x01a\x1D!V[\x95\x98\x94\x97P\x95PPPPV[______`\x80\x87\x89\x03\x12\x15a\x1E\xF3W__\xFD[\x865\x95P` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x10W__\xFD[a\x1F\x1C\x89\x82\x8A\x01a\x1D!V[\x90\x96P\x94PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F;W__\xFD[a\x1FG\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97\x94\x96\x95``\x90\x95\x015\x94\x93PPPPV[______``\x87\x89\x03\x12\x15a\x1FtW__\xFD[\x865g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\x8AW__\xFD[a\x1F\x96\x89\x82\x8A\x01a\x1D!V[\x90\x97P\x95PP` \x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xB5W__\xFD[a\x1F\xC1\x89\x82\x8A\x01a\x1D!V[\x90\x95P\x93PP`@\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x1F\xE0W__\xFD[a\x1F\xEC\x89\x82\x8A\x01a\x1D!V[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[_____``\x86\x88\x03\x12\x15a \x12W__\xFD[\x855\x94P` \x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a /W__\xFD[a ;\x88\x82\x89\x01a\x1D!V[\x90\x95P\x93PP`@\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a ZW__\xFD[a f\x88\x82\x89\x01a\x1D!V[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[___``\x84\x86\x03\x12\x15a \x89W__\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[__`@\x83\x85\x03\x12\x15a \xB1W__\xFD[\x825\x91Pa \xC1` \x84\x01a\x1DfV[\x90P\x92P\x92\x90PV[\x805\x80\x15\x15\x81\x14a\x1DvW__\xFD[__`@\x83\x85\x03\x12\x15a \xEAW__\xFD[a \xF3\x83a \xCAV[\x91Pa \xC1` \x84\x01a \xCAV[\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!^<#\x14a\x01VW[__\xFD[a\x01!a\x025V[\0[a\x01+a\x02rV[`@Qa\x018\x91\x90a\x14\x8CV[`@Q\x80\x91\x03\x90\xF3[a\x01Ia\x02\xD2V[`@Qa\x018\x91\x90a\x15\x05V[a\x01+a\x04\x0EV[a\x01+a\x04lV[a\x01na\x04\xCAV[`@Qa\x018\x91\x90a\x16HV[a\x01!a\x06CV[a\x01\x8Ba\t\x94V[`@Qa\x018\x91\x90a\x16\xC6V[a\x01\xA0a\n_V[`@Qa\x018\x91\x90a\x17\x1DV[a\x01\xA0a\x0BUV[a\x01\x8Ba\x0CKV[a\x01\xC5a\r\x16V[`@Q\x90\x15\x15\x81R` \x01a\x018V[a\x01+a\r\xE6V[a\x01!a\x0EDV[a\x01!a\x01\xF36`\x04a\x17\xAFV[a\x11\xB3V[`\x1FTa\x01\xC5\x90`\xFF\x16\x81V[`\x1FTa\x02\x1D\x90a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x018V[a\x02pb\\\xBA\x95sZ\x8E\x97t\xD6\x7F\xE8F\xC6\xF41\x1C\x07>*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x11\xB3V[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xC8W` \x02\x82\x01\x91\x90_R` _ \x90[\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xAAW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x03\xEEW\x83\x82\x90_R` _ \x01\x80Ta\x03c\x90a\x17\xF0V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\x8F\x90a\x17\xF0V[\x80\x15a\x03\xDAW\x80`\x1F\x10a\x03\xB1Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xDAV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xBDW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03FV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xF5V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xC8W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xAAWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xC8W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xAAWPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x05\x1D\x90a\x17\xF0V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05I\x90a\x17\xF0V[\x80\x15a\x05\x94W\x80`\x1F\x10a\x05kWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05\x94V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05wW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06+W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x05\xD8W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x04\xEDV[_sT\x1F\xD7IA\x9C\xA8\x06\xA8\xBC}\xA8\xAC#\xD3F\xF2\xDF\x8Bw\x90P_sI\xB0r\x15\x85d\xDB60E\x18\xFF\xA3{\x1C\xFC\x13\x91j\x90\x7FVdR\x02@\xA4kK>\x96U\xC2\x0C\xC3\xF9\xE0\x84\x96\xA9\xB7F\xA4x\xE4v\xAE>\x04\xD6\xC8\xFC1\x83`@Qa\x06\x9F\x90a\x14rV[`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x81R` \x81\x01\x92\x90\x92R\x90\x91\x16`@\x82\x01R``\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x06\xD8W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07RW__\xFD[PZ\xF1\x15\x80\x15a\x07dW=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x07\xDAW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xFE\x91\x90a\x18AV[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\x85W__\xFD[PZ\xF1\x15\x80\x15a\x08\x97W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\xE7W__\xFD[PZ\xF1\x15\x80\x15a\x08\xF9W=__>=_\xFD[PP`@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\x81R`\x01`\x04\x82\x01Ra\t\x90\x92P`\x01`\x01`\xA0\x1B\x03\x85\x16\x91Pcp\xA0\x821\x90`$\x01[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\t^W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\x82\x91\x90a\x18gV[g\r\xE0\xB6\xB3\xA7d\0\0a\x13\xEFV[PPV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W\x83\x82\x90_R` _ \x01\x80Ta\t\xD4\x90a\x17\xF0V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n\0\x90a\x17\xF0V[\x80\x15a\nKW\x80`\x1F\x10a\n\"Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\nKV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\n.W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\t\xB7V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0B=W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\n\xEAW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\n\x82V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C3W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0B\xE0W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0BxV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W\x83\x82\x90_R` _ \x01\x80Ta\x0C\x8B\x90a\x17\xF0V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C\xB7\x90a\x17\xF0V[\x80\x15a\r\x02W\x80`\x1F\x10a\x0C\xD9Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\r\x02V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0C\xE5W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0CnV[`\x08T_\x90`\xFF\x16\x15a\r-WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\r\xBBW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\xDF\x91\x90a\x18gV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xC8W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xAAWPPPPP\x90P\x90V[_sT\x1F\xD7IA\x9C\xA8\x06\xA8\xBC}\xA8\xAC#\xD3F\xF2\xDF\x8Bw\x90P_s\xCC\tf\xD8A\x8DA,Y\x9Ad!\xB7`\xA8G\xEB\x16\x9A\x8C\x90P_sI\xB0r\x15\x85d\xDB60E\x18\xFF\xA3{\x1C\xFC\x13\x91j\x90s\xBAF\xFC\xC1kFM\x97\x871Ag\xBD\xD9\xF1\xCE(@[\xA1\x7FVdR\x02@\xA4kK>\x96U\xC2\x0C\xC3\xF9\xE0\x84\x96\xA9\xB7F\xA4x\xE4v\xAE>\x04\xD6\xC8\xFC1\x7Fh\x99\xA7\xE1;e_\xA3g \x8C\xB2|n\xAA$\x107\r\x15e\xDC\x1F_\x11\x85:\x1E\x8C\xBE\xF03\x86\x86`@Qa\x0E\xEF\x90a\x14\x7FV[`\x01`\x01`\xA0\x1B\x03\x96\x87\x16\x81R\x94\x86\x16` \x86\x01R`@\x85\x01\x93\x90\x93R``\x84\x01\x91\x90\x91R\x83\x16`\x80\x83\x01R\x90\x91\x16`\xA0\x82\x01R`\xC0\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x0F?W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0F\xB9W__\xFD[PZ\xF1\x15\x80\x15a\x0F\xCBW=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10AW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10e\x91\x90a\x18AV[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10\xECW__\xFD[PZ\xF1\x15\x80\x15a\x10\xFEW=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x11NW__\xFD[PZ\xF1\x15\x80\x15a\x11`W=__>=_\xFD[PP`@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\x81R`\x01`\x04\x82\x01Ra\x11\xAE\x92P`\x01`\x01`\xA0\x1B\x03\x85\x16\x91Pcp\xA0\x821\x90`$\x01a\tCV[PPPV[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x12NW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x12u\x91\x90\x81\x01\x90a\x18\xABV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x12\x93\x92\x91\x90a\x19_V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x12\xAFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xD3\x91\x90a\x18gV[P`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x13?W__\xFD[PZ\xF1\x15\x80\x15a\x13QW=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x13\xC4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13\xE8\x91\x90a\x18AV[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x14XW__\xFD[PZ\xFA\x15\x80\x15a\x14jW=__>=_\xFD[PPPPPPV[a\x0C\xE3\x80a\x19\x81\x839\x01\x90V[a\x0F-\x80a&d\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x14\xCCW\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x14\xA5V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\xE0W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`\x01`\x01`\xA0\x1B\x03\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x15\xC6W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x15\xB0\x84\x86Qa\x14\xD7V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x15vV[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x15+V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x16>W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x15\xFEV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\xE0W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x16\x94`@\x88\x01\x82a\x14\xD7V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x16\xAF\x81\x83a\x15\xECV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16nV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\xE0W`?\x19\x87\x86\x03\x01\x84Ra\x17\x08\x85\x83Qa\x14\xD7V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16\xECV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\xE0W`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x17~`@\x87\x01\x82a\x15\xECV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x17CV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x17\xAAW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x17\xC2W__\xFD[\x845\x93Pa\x17\xD2` \x86\x01a\x17\x94V[\x92Pa\x17\xE0`@\x86\x01a\x17\x94V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x18\x04W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x18;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`\"`\x04R`$_\xFD[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x18QW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x18`W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x18wW__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x18\xBBW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\xD1W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x18\xE1W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\xFBWa\x18\xFBa\x18~V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x19+Wa\x19+a\x18~V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x19BW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x19q`@\x83\x01\x85a\x14\xD7V[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xE0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x0C\xE38\x03\x80a\x0C\xE3\x839\x81\x01`@\x81\x90Ra\0.\x91a\0bV[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16`\x80R`\xA0\x91\x90\x91R\x16`\xC0Ra\0\xA2V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0_W__\xFD[PV[___``\x84\x86\x03\x12\x15a\0tW__\xFD[\x83Qa\0\x7F\x81a\0KV[` \x85\x01Q`@\x86\x01Q\x91\x94P\x92Pa\0\x97\x81a\0KV[\x80\x91PP\x92P\x92P\x92V[`\x80Q`\xA0Q`\xC0Qa\x0B\xF6a\0\xED_9_\x81\x81a\x01\x1B\x01R\x81\x81a\x03-\x01Ra\x03o\x01R_\x81\x81`\xBE\x01Ra\x01\xF2\x01R_\x81\x81`m\x01R\x81\x81a\x01\xA5\x01Ra\x02!\x01Ra\x0B\xF6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0dW_5`\xE0\x1C\x80cPcL\x0E\x11a\0MW\x80cPcL\x0E\x14a\0\xEEW\x80c\x7F\x81O5\x14a\x01\x03W\x80c\xB9\x93|\xCB\x14a\x01\x16W__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0hW\x80c>\r\xC3N\x14a\0\xB9W[__\xFD[a\0\x8F\x7F\0\0\0\0\0\0\0\0\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\xE0\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xB0V[a\x01\x01a\0\xFC6`\x04a\t\x97V[a\x01=V[\0[a\x01\x01a\x01\x116`\x04a\nYV[a\x01gV[a\0\x8F\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01R\x91\x90a\n\xDDV[\x90Pa\x01`\x85\x85\x85\x84a\x01gV[PPPPPV[a\x01\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x03\xCAV[a\x01\xCAs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\x8EV[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02|W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xA0\x91\x90a\x0B\x01V[\x82Q\x90\x91P\x81\x10\x15a\x03\x13W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03Ts\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\x84\x83a\x05\x89V[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\x88\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xE4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x02W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05&\x91\x90a\x0B\x01V[a\x050\x91\x90a\x0B\x18V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\x88\x90\x85\x90\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\x90`d\x01a\x04$V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x05\xDF\x90\x84\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\x90`d\x01a\x04$V[PPPV[_a\x06E\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\x06\xEF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x05\xDFW\x80\x80` \x01\x90Q\x81\x01\x90a\x06c\x91\x90a\x0BVV[a\x05\xDFW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[``a\x06\xFD\x84\x84_\x85a\x07\x07V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\x99W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\x17W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[__\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\x08?\x91\x90a\x0BuV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08yW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08~V[``\x91P[P\x91P\x91Pa\x08\x8E\x82\x82\x86a\x08\x99V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xA8WP\x81a\x07\0V[\x82Q\x15a\x08\xB8W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\n\x91\x90a\x0B\x8BV[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\t\rW__\xFD[PV[\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`Wa\t`a\t\x10V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\x8FWa\t\x8Fa\t\x10V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xAAW__\xFD[\x845a\t\xB5\x81a\x08\xECV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xCC\x81a\x08\xECV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xE7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\t\xF7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x11Wa\n\x11a\t\x10V[a\n$` `\x1F\x19`\x1F\x84\x01\x16\x01a\tfV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n8W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\nmW__\xFD[\x855a\nx\x81a\x08\xECV[\x94P` \x86\x015\x93P`@\x86\x015a\n\x8F\x81a\x08\xECV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xC0W__\xFD[Pa\n\xC9a\t=V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\n\xEEW__\xFD[Pa\n\xF7a\t=V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\x11W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0BPW\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[_` \x82\x84\x03\x12\x15a\x0BfW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\0W__\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\xFE\xA2dipfsX\"\x12 \xEA:\x8D\x8D\x03\xA7\x99\xDE\xBEZ\xF3\x80t\xA1\xC6S\x89f\xE8#\xECG\xA2\xDDfH\x1F<\x94\xF2SxdsolcC\0\x08\x1C\x003a\x01@`@R4\x80\x15a\0\x10W__\xFD[P`@Qa\x0F-8\x03\x80a\x0F-\x839\x81\x01`@\x81\x90Ra\0/\x91a\0sV[`\x01`\x01`\xA0\x1B\x03\x95\x86\x16`\x80R\x93\x85\x16`\xA0R`\xC0\x92\x90\x92R`\xE0R\x82\x16a\x01\0R\x16a\x01 Ra\0\xE3V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0pW__\xFD[PV[______`\xC0\x87\x89\x03\x12\x15a\0\x88W__\xFD[\x86Qa\0\x93\x81a\0\\V[` \x88\x01Q\x90\x96Pa\0\xA4\x81a\0\\V[`@\x88\x01Q``\x89\x01Q`\x80\x8A\x01Q\x92\x97P\x90\x95P\x93Pa\0\xC4\x81a\0\\V[`\xA0\x88\x01Q\x90\x92Pa\0\xD5\x81a\0\\V[\x80\x91PP\x92\x95P\x92\x95P\x92\x95V[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\r\xC6a\x01g_9_\x81\x81a\x01.\x01R\x81\x81a\x04\xFC\x01Ra\x05>\x01R_\x81\x81a\x01U\x01Ra\x03R\x01R_\x81\x81a\x01\xB1\x01Ra\x03\xC1\x01R_\x81\x81a\x01|\x01Ra\x02\x88\x01R_\x81\x81`\xDF\x01R\x81\x81a\x03t\x01Ra\x03\xF0\x01R_\x81\x81`\x8E\x01R\x81\x81a\x02;\x01Ra\x02\xB7\x01Ra\r\xC6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\x85W_5`\xE0\x1C\x80c\xADt}\xE6\x11a\0XW\x80c\xADt}\xE6\x14a\x01)W\x80c\xB9\x93|\xCB\x14a\x01PW\x80c\xC8\xC7\xF7\x01\x14a\x01wW\x80c\xE3L\xEF\x86\x14a\x01\xACW__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0\x89W\x80cN=\xF3\xF4\x14a\0\xDAW\x80cPcL\x0E\x14a\x01\x01W\x80c\x7F\x81O5\x14a\x01\x16W[__\xFD[a\0\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\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\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\x81V[a\x01\x14a\x01\x0F6`\x04a\x0BgV[a\x01\xD3V[\0[a\x01\x14a\x01$6`\x04a\x0C)V[a\x01\xFDV[a\0\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\x81V[a\0\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\x81V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xD1V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\xE8\x91\x90a\x0C\xADV[\x90Pa\x01\xF6\x85\x85\x85\x84a\x01\xFDV[PPPPPV[a\x02\x1Fs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x9AV[a\x02`s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x036\x91\x90a\x0C\xD1V[\x90Pa\x03\x99s\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\x7F\0\0\0\0\0\0\0\0\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\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x82\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04KW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04o\x91\x90a\x0C\xD1V[\x83Q\x90\x91P\x81\x10\x15a\x04\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[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\x85\x83a\x07YV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x06X\x90\x85\x90\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\x90`\x84\x01[`@\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\x07\xB4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF6\x91\x90a\x0C\xD1V[a\x07\0\x91\x90a\x0C\xE8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x06X\x90\x85\x90\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\x90`d\x01a\x05\xF4V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07\xAF\x90\x84\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\x90`d\x01a\x05\xF4V[PPPV[_a\x08\x15\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\x08\xBF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\xAFW\x80\x80` \x01\x90Q\x81\x01\x90a\x083\x91\x90a\r&V[a\x07\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\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\x04\xD9V[``a\x08\xCD\x84\x84_\x85a\x08\xD7V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\tiW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x04\xD9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\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`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x04\xD9V[__\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\n\x0F\x91\x90a\rEV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\nIW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\nNV[``\x91P[P\x91P\x91Pa\n^\x82\x82\x86a\niV[\x97\x96PPPPPPPV[``\x83\x15a\nxWP\x81a\x08\xD0V[\x82Q\x15a\n\x88W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x04\xD9\x91\x90a\r[V[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\xDDW__\xFD[PV[\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\x0B0Wa\x0B0a\n\xE0V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0B_Wa\x0B_a\n\xE0V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0BzW__\xFD[\x845a\x0B\x85\x81a\n\xBCV[\x93P` \x85\x015\x92P`@\x85\x015a\x0B\x9C\x81a\n\xBCV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xB7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\x0B\xC7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xE1Wa\x0B\xE1a\n\xE0V[a\x0B\xF4` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0B6V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0C\x08W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0C=W__\xFD[\x855a\x0CH\x81a\n\xBCV[\x94P` \x86\x015\x93P`@\x86\x015a\x0C_\x81a\n\xBCV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0C\x90W__\xFD[Pa\x0C\x99a\x0B\rV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0C\xBEW__\xFD[Pa\x0C\xC7a\x0B\rV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C\xE1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\r 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[_` \x82\x84\x03\x12\x15a\r6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x08\xD0W__\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\xFE\xA2dipfsX\"\x12 \xD28\x8C\xB3\xDCz\xA6\xF5\xA2\xEBuA}\x11\x05\x9B\xE1<\x8C\x9E\xAB\xE5\xD7\xEA\xDB\x1BV\x1F\x93\x7F\xF6\x91dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 \xBE\xBAcC7\xF2ib\xD3\xA2*^\xDC\x8C)\xAE\xFEz\xB3T\x85\xB7\x1D<\xCC\x01\xFB\xE1.[\xEF\xF6dsolcC\0\x08\x1C\x003", ); /// 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\xFBW_5`\xE0\x1C\x80c\x85\"l\x81\x11a\0\x93W\x80c\xBAAO\xA6\x11a\0cW\x80c\xBAAO\xA6\x14a\x01\xF1W\x80c\xE2\x0C\x9Fq\x14a\x02\tW\x80c\xFAv&\xD4\x14a\x02\x11W\x80c\xFA\xD0k\x8F\x14a\x02\x1EW__\xFD[\x80c\x85\"l\x81\x14a\x01\xB7W\x80c\x91j\x17\xC6\x14a\x01\xCCW\x80c\xB0FO\xDC\x14a\x01\xE1W\x80c\xB5P\x8A\xA9\x14a\x01\xE9W__\xFD[\x80c>^<#\x11a\0\xCEW\x80c>^<#\x14a\x01rW\x80c?r\x86\xF4\x14a\x01zW\x80cD\xBA\xDB\xB6\x14a\x01\x82W\x80cf\xD9\xA9\xA0\x14a\x01\xA2W__\xFD[\x80c\x08\x13\x85*\x14a\0\xFFW\x80c\x1C\r\xA8\x1F\x14a\x01(W\x80c\x1E\xD7\x83\x1C\x14a\x01HW\x80c*\xDE8\x80\x14a\x01]W[__\xFD[a\x01\x12a\x01\r6`\x04a\x13\x89V[a\x021V[`@Qa\x01\x1F\x91\x90a\x14>V[`@Q\x80\x91\x03\x90\xF3[a\x01;a\x0166`\x04a\x13\x89V[a\x02|V[`@Qa\x01\x1F\x91\x90a\x14\xA1V[a\x01Pa\x02\xEEV[`@Qa\x01\x1F\x91\x90a\x14\xB3V[a\x01ea\x03[V[`@Qa\x01\x1F\x91\x90a\x15eV[a\x01Pa\x04\xA4V[a\x01Pa\x05\x0FV[a\x01\x95a\x01\x906`\x04a\x13\x89V[a\x05zV[`@Qa\x01\x1F\x91\x90a\x15\xE9V[a\x01\xAAa\x05\xBDV[`@Qa\x01\x1F\x91\x90a\x16|V[a\x01\xBFa\x076V[`@Qa\x01\x1F\x91\x90a\x16\xFAV[a\x01\xD4a\x08\x01V[`@Qa\x01\x1F\x91\x90a\x17\x0CV[a\x01\xD4a\t\x04V[a\x01\xBFa\n\x07V[a\x01\xF9a\n\xD2V[`@Q\x90\x15\x15\x81R` \x01a\x01\x1FV[a\x01Pa\x0B\xA2V[`\x1FTa\x01\xF9\x90`\xFF\x16\x81V[a\x01\x95a\x02,6`\x04a\x13\x89V[a\x0C\rV[``a\x02t\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x03\x81R` \x01\x7Fhex\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x0CPV[\x94\x93PPPPV[``_a\x02\x8A\x85\x85\x85a\x021V[\x90P_[a\x02\x98\x85\x85a\x17\xBDV[\x81\x10\x15a\x02\xE5W\x82\x82\x82\x81Q\x81\x10a\x02\xB2Wa\x02\xB2a\x17\xD0V[` \x02` \x01\x01Q`@Q` \x01a\x02\xCB\x92\x91\x90a\x18\x14V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x91\x90R\x92P`\x01\x01a\x02\x8EV[PP\x93\x92PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03QW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03&W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\x84W\x83\x82\x90_R` _ \x01\x80Ta\x03\xF9\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x04%\x90a\x18(V[\x80\x15a\x04pW\x80`\x1F\x10a\x04GWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x04pV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x04SW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03\xDCV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x03~V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03QW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03&WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03QW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03&WPPPPP\x90P\x90V[``a\x02t\x84\x84\x84`@Q\x80`@\x01`@R\x80`\t\x81R` \x01\x7Fdigest_le\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\r\xB1V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x06\x10\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06<\x90a\x18(V[\x80\x15a\x06\x87W\x80`\x1F\x10a\x06^Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x06\x87V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x06jW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07\x1EW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x06\xCBW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05\xE0V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW\x83\x82\x90_R` _ \x01\x80Ta\x07v\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07\xA2\x90a\x18(V[\x80\x15a\x07\xEDW\x80`\x1F\x10a\x07\xC4Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07\xEDV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\xD0W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x07YV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x08\xECW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x08\x99W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x08$V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\t\xEFW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\t\x9CW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\t'V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9BW\x83\x82\x90_R` _ \x01\x80Ta\nG\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\ns\x90a\x18(V[\x80\x15a\n\xBEW\x80`\x1F\x10a\n\x95Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\xBEV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\n\xA1W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\n*V[`\x08T_\x90`\xFF\x16\x15a\n\xE9WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0BwW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\x9B\x91\x90a\x18yV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03QW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03&WPPPPP\x90P\x90V[``a\x02t\x84\x84\x84`@Q\x80`@\x01`@R\x80`\x06\x81R` \x01\x7Fheight\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x0E\xFFV[``a\x0C\\\x84\x84a\x17\xBDV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0CtWa\x0Cta\x13\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0C\xA7W\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x0C\x92W\x90P[P\x90P\x83[\x83\x81\x10\x15a\r\xA8Wa\rz\x86a\x0C\xC1\x83a\x10MV[\x85`@Q` \x01a\x0C\xD4\x93\x92\x91\x90a\x18\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x0C\xF0\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\x1C\x90a\x18(V[\x80\x15a\rgW\x80`\x1F\x10a\r>Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rgV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\rJW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x11~\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\r\x85\x87\x84a\x17\xBDV[\x81Q\x81\x10a\r\x95Wa\r\x95a\x17\xD0V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x0C\xACV[P\x94\x93PPPPV[``a\r\xBD\x84\x84a\x17\xBDV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\xD5Wa\r\xD5a\x13\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\r\xFEW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\r\xA8Wa\x0E\xD1\x86a\x0E\x18\x83a\x10MV[\x85`@Q` \x01a\x0E+\x93\x92\x91\x90a\x18\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x0EG\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0Es\x90a\x18(V[\x80\x15a\x0E\xBEW\x80`\x1F\x10a\x0E\x95Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0E\xBEV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0E\xA1W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x12\x1D\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x0E\xDC\x87\x84a\x17\xBDV[\x81Q\x81\x10a\x0E\xECWa\x0E\xECa\x17\xD0V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x0E\x03V[``a\x0F\x0B\x84\x84a\x17\xBDV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0F#Wa\x0F#a\x13\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0FLW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P\x83[\x83\x81\x10\x15a\r\xA8Wa\x10\x1F\x86a\x0Ff\x83a\x10MV[\x85`@Q` \x01a\x0Fy\x93\x92\x91\x90a\x18\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R` \x80Ta\x0F\x95\x90a\x18(V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F\xC1\x90a\x18(V[\x80\x15a\x10\x0CW\x80`\x1F\x10a\x0F\xE3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x10\x0CV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\xEFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPPa\x12\xB0\x90\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x82a\x10*\x87\x84a\x17\xBDV[\x81Q\x81\x10a\x10:Wa\x10:a\x17\xD0V[` \x90\x81\x02\x91\x90\x91\x01\x01R`\x01\x01a\x0FQV[``\x81_\x03a\x10\x8FWPP`@\x80Q\x80\x82\x01\x90\x91R`\x01\x81R\x7F0\0\0\0\0\0\0\0\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\x90V[\x81_[\x81\x15a\x10\xB8W\x80a\x10\xA2\x81a\x19-V[\x91Pa\x10\xB1\x90P`\n\x83a\x19\x91V[\x91Pa\x10\x92V[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10\xD2Wa\x10\xD2a\x13\x04V[`@Q\x90\x80\x82R\x80`\x1F\x01`\x1F\x19\x16` \x01\x82\x01`@R\x80\x15a\x10\xFCW` \x82\x01\x81\x806\x837\x01\x90P[P\x90P[\x84\x15a\x02tWa\x11\x11`\x01\x83a\x17\xBDV[\x91Pa\x11\x1E`\n\x86a\x19\xA4V[a\x11)\x90`0a\x19\xB7V[`\xF8\x1B\x81\x83\x81Q\x81\x10a\x11>Wa\x11>a\x17\xD0V[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SPa\x11w`\n\x86a\x19\x91V[\x94Pa\x11\0V[`@Q\x7F\xFD\x92\x1B\xE8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R``\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xFD\x92\x1B\xE8\x90a\x11\xD3\x90\x86\x90\x86\x90`\x04\x01a\x19\xCAV[_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\xEDW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x12\x14\x91\x90\x81\x01\x90a\x19\xF7V[\x90P[\x92\x91PPV[`@Q\x7F\x17w\xE5\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_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x17w\xE5\x9D\x90a\x12q\x90\x86\x90\x86\x90`\x04\x01a\x19\xCAV[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x12\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\x14\x91\x90a\x18yV[`@Q\x7F\xAD\xDD\xE2\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\x81R_\x90sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xAD\xDD\xE2\xB6\x90a\x12q\x90\x86\x90\x86\x90`\x04\x01a\x19\xCAV[\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`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x13ZWa\x13Za\x13\x04V[`@R\x91\x90PV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x13{Wa\x13{a\x13\x04V[P`\x1F\x01`\x1F\x19\x16` \x01\x90V[___``\x84\x86\x03\x12\x15a\x13\x9BW__\xFD[\x835g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x13\xB1W__\xFD[\x84\x01`\x1F\x81\x01\x86\x13a\x13\xC1W__\xFD[\x805a\x13\xD4a\x13\xCF\x82a\x13bV[a\x131V[\x81\x81R\x87` \x83\x85\x01\x01\x11\x15a\x13\xE8W__\xFD[\x81` \x84\x01` \x83\x017_` \x92\x82\x01\x83\x01R\x97\x90\x86\x015\x96P`@\x90\x95\x015\x94\x93PPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\x95W`?\x19\x87\x86\x03\x01\x84Ra\x14\x80\x85\x83Qa\x14\x10V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14dV[P\x92\x96\x95PPPPPPV[` \x81R_a\x12\x14` \x83\x01\x84a\x14\x10V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x15\0W\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\x14\xCCV[P\x90\x95\x94PPPPPV[_\x82\x82Q\x80\x85R` \x85\x01\x94P` \x81`\x05\x1B\x83\x01\x01` \x85\x01_[\x83\x81\x10\x15a\x15YW`\x1F\x19\x85\x84\x03\x01\x88Ra\x15C\x83\x83Qa\x14\x10V[` \x98\x89\x01\x98\x90\x93P\x91\x90\x91\x01\x90`\x01\x01a\x15'V[P\x90\x96\x95PPPPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\x95W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x15\xD3`@\x87\x01\x82a\x15\x0BV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\x8BV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x15\0W\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x16\x02V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x16rW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x162V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\x95W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x16\xC8`@\x88\x01\x82a\x14\x10V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x16\xE3\x81\x83a\x16 V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16\xA2V[` \x81R_a\x12\x14` \x83\x01\x84a\x15\x0BV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\x95W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x17z`@\x87\x01\x82a\x16 V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x172V[\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\x12\x17Wa\x12\x17a\x17\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_a\x02ta\x18\"\x83\x86a\x17\xFDV[\x84a\x17\xFDV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x18^<#\x14a\x01VW[__\xFD[a\x01!a\x025V[\0[a\x01+a\x02rV[`@Qa\x018\x91\x90a\x14\x8CV[`@Q\x80\x91\x03\x90\xF3[a\x01Ia\x02\xD2V[`@Qa\x018\x91\x90a\x15\x05V[a\x01+a\x04\x0EV[a\x01+a\x04lV[a\x01na\x04\xCAV[`@Qa\x018\x91\x90a\x16HV[a\x01!a\x06CV[a\x01\x8Ba\t\x94V[`@Qa\x018\x91\x90a\x16\xC6V[a\x01\xA0a\n_V[`@Qa\x018\x91\x90a\x17\x1DV[a\x01\xA0a\x0BUV[a\x01\x8Ba\x0CKV[a\x01\xC5a\r\x16V[`@Q\x90\x15\x15\x81R` \x01a\x018V[a\x01+a\r\xE6V[a\x01!a\x0EDV[a\x01!a\x01\xF36`\x04a\x17\xAFV[a\x11\xB3V[`\x1FTa\x01\xC5\x90`\xFF\x16\x81V[`\x1FTa\x02\x1D\x90a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x018V[a\x02pb\\\xBA\x95sZ\x8E\x97t\xD6\x7F\xE8F\xC6\xF41\x1C\x07>*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x11\xB3V[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xC8W` \x02\x82\x01\x91\x90_R` _ \x90[\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xAAW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x03\xEEW\x83\x82\x90_R` _ \x01\x80Ta\x03c\x90a\x17\xF0V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\x8F\x90a\x17\xF0V[\x80\x15a\x03\xDAW\x80`\x1F\x10a\x03\xB1Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xDAV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xBDW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03FV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xF5V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xC8W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xAAWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xC8W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xAAWPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x05\x1D\x90a\x17\xF0V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05I\x90a\x17\xF0V[\x80\x15a\x05\x94W\x80`\x1F\x10a\x05kWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05\x94V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05wW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06+W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x05\xD8W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x04\xEDV[_sT\x1F\xD7IA\x9C\xA8\x06\xA8\xBC}\xA8\xAC#\xD3F\xF2\xDF\x8Bw\x90P_sI\xB0r\x15\x85d\xDB60E\x18\xFF\xA3{\x1C\xFC\x13\x91j\x90\x7FVdR\x02@\xA4kK>\x96U\xC2\x0C\xC3\xF9\xE0\x84\x96\xA9\xB7F\xA4x\xE4v\xAE>\x04\xD6\xC8\xFC1\x83`@Qa\x06\x9F\x90a\x14rV[`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x81R` \x81\x01\x92\x90\x92R\x90\x91\x16`@\x82\x01R``\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x06\xD8W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07RW__\xFD[PZ\xF1\x15\x80\x15a\x07dW=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x07\xDAW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xFE\x91\x90a\x18AV[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\x85W__\xFD[PZ\xF1\x15\x80\x15a\x08\x97W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\xE7W__\xFD[PZ\xF1\x15\x80\x15a\x08\xF9W=__>=_\xFD[PP`@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\x81R`\x01`\x04\x82\x01Ra\t\x90\x92P`\x01`\x01`\xA0\x1B\x03\x85\x16\x91Pcp\xA0\x821\x90`$\x01[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\t^W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\x82\x91\x90a\x18gV[g\r\xE0\xB6\xB3\xA7d\0\0a\x13\xEFV[PPV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W\x83\x82\x90_R` _ \x01\x80Ta\t\xD4\x90a\x17\xF0V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n\0\x90a\x17\xF0V[\x80\x15a\nKW\x80`\x1F\x10a\n\"Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\nKV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\n.W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\t\xB7V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0B=W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\n\xEAW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\n\x82V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C3W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0B\xE0W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0BxV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W\x83\x82\x90_R` _ \x01\x80Ta\x0C\x8B\x90a\x17\xF0V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C\xB7\x90a\x17\xF0V[\x80\x15a\r\x02W\x80`\x1F\x10a\x0C\xD9Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\r\x02V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0C\xE5W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0CnV[`\x08T_\x90`\xFF\x16\x15a\r-WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\r\xBBW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\xDF\x91\x90a\x18gV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xC8W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xAAWPPPPP\x90P\x90V[_sT\x1F\xD7IA\x9C\xA8\x06\xA8\xBC}\xA8\xAC#\xD3F\xF2\xDF\x8Bw\x90P_s\xCC\tf\xD8A\x8DA,Y\x9Ad!\xB7`\xA8G\xEB\x16\x9A\x8C\x90P_sI\xB0r\x15\x85d\xDB60E\x18\xFF\xA3{\x1C\xFC\x13\x91j\x90s\xBAF\xFC\xC1kFM\x97\x871Ag\xBD\xD9\xF1\xCE(@[\xA1\x7FVdR\x02@\xA4kK>\x96U\xC2\x0C\xC3\xF9\xE0\x84\x96\xA9\xB7F\xA4x\xE4v\xAE>\x04\xD6\xC8\xFC1\x7Fh\x99\xA7\xE1;e_\xA3g \x8C\xB2|n\xAA$\x107\r\x15e\xDC\x1F_\x11\x85:\x1E\x8C\xBE\xF03\x86\x86`@Qa\x0E\xEF\x90a\x14\x7FV[`\x01`\x01`\xA0\x1B\x03\x96\x87\x16\x81R\x94\x86\x16` \x86\x01R`@\x85\x01\x93\x90\x93R``\x84\x01\x91\x90\x91R\x83\x16`\x80\x83\x01R\x90\x91\x16`\xA0\x82\x01R`\xC0\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x0F?W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0F\xB9W__\xFD[PZ\xF1\x15\x80\x15a\x0F\xCBW=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10AW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10e\x91\x90a\x18AV[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10\xECW__\xFD[PZ\xF1\x15\x80\x15a\x10\xFEW=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x11NW__\xFD[PZ\xF1\x15\x80\x15a\x11`W=__>=_\xFD[PP`@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\x81R`\x01`\x04\x82\x01Ra\x11\xAE\x92P`\x01`\x01`\xA0\x1B\x03\x85\x16\x91Pcp\xA0\x821\x90`$\x01a\tCV[PPPV[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x12NW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x12u\x91\x90\x81\x01\x90a\x18\xABV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x12\x93\x92\x91\x90a\x19_V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x12\xAFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xD3\x91\x90a\x18gV[P`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x13?W__\xFD[PZ\xF1\x15\x80\x15a\x13QW=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x13\xC4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13\xE8\x91\x90a\x18AV[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x14XW__\xFD[PZ\xFA\x15\x80\x15a\x14jW=__>=_\xFD[PPPPPPV[a\x0C\xE3\x80a\x19\x81\x839\x01\x90V[a\x0F-\x80a&d\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x14\xCCW\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x14\xA5V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\xE0W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`\x01`\x01`\xA0\x1B\x03\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x15\xC6W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x15\xB0\x84\x86Qa\x14\xD7V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x15vV[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x15+V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x16>W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x15\xFEV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\xE0W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x16\x94`@\x88\x01\x82a\x14\xD7V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x16\xAF\x81\x83a\x15\xECV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16nV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\xE0W`?\x19\x87\x86\x03\x01\x84Ra\x17\x08\x85\x83Qa\x14\xD7V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16\xECV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\xE0W`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x17~`@\x87\x01\x82a\x15\xECV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x17CV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x17\xAAW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x17\xC2W__\xFD[\x845\x93Pa\x17\xD2` \x86\x01a\x17\x94V[\x92Pa\x17\xE0`@\x86\x01a\x17\x94V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x18\x04W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x18;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`\"`\x04R`$_\xFD[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x18QW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x18`W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x18wW__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x18\xBBW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\xD1W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x18\xE1W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\xFBWa\x18\xFBa\x18~V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x19+Wa\x19+a\x18~V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x19BW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x19q`@\x83\x01\x85a\x14\xD7V[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xE0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x0C\xE38\x03\x80a\x0C\xE3\x839\x81\x01`@\x81\x90Ra\0.\x91a\0bV[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16`\x80R`\xA0\x91\x90\x91R\x16`\xC0Ra\0\xA2V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0_W__\xFD[PV[___``\x84\x86\x03\x12\x15a\0tW__\xFD[\x83Qa\0\x7F\x81a\0KV[` \x85\x01Q`@\x86\x01Q\x91\x94P\x92Pa\0\x97\x81a\0KV[\x80\x91PP\x92P\x92P\x92V[`\x80Q`\xA0Q`\xC0Qa\x0B\xF6a\0\xED_9_\x81\x81a\x01\x1B\x01R\x81\x81a\x03-\x01Ra\x03o\x01R_\x81\x81`\xBE\x01Ra\x01\xF2\x01R_\x81\x81`m\x01R\x81\x81a\x01\xA5\x01Ra\x02!\x01Ra\x0B\xF6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0dW_5`\xE0\x1C\x80cPcL\x0E\x11a\0MW\x80cPcL\x0E\x14a\0\xEEW\x80c\x7F\x81O5\x14a\x01\x03W\x80c\xB9\x93|\xCB\x14a\x01\x16W__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0hW\x80c>\r\xC3N\x14a\0\xB9W[__\xFD[a\0\x8F\x7F\0\0\0\0\0\0\0\0\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\xE0\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xB0V[a\x01\x01a\0\xFC6`\x04a\t\x97V[a\x01=V[\0[a\x01\x01a\x01\x116`\x04a\nYV[a\x01gV[a\0\x8F\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01R\x91\x90a\n\xDDV[\x90Pa\x01`\x85\x85\x85\x84a\x01gV[PPPPPV[a\x01\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x03\xCAV[a\x01\xCAs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\x8EV[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02|W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xA0\x91\x90a\x0B\x01V[\x82Q\x90\x91P\x81\x10\x15a\x03\x13W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03Ts\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\x84\x83a\x05\x89V[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\x88\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xE4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x02W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05&\x91\x90a\x0B\x01V[a\x050\x91\x90a\x0B\x18V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\x88\x90\x85\x90\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\x90`d\x01a\x04$V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x05\xDF\x90\x84\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\x90`d\x01a\x04$V[PPPV[_a\x06E\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\x06\xEF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x05\xDFW\x80\x80` \x01\x90Q\x81\x01\x90a\x06c\x91\x90a\x0BVV[a\x05\xDFW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[``a\x06\xFD\x84\x84_\x85a\x07\x07V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\x99W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\x17W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[__\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\x08?\x91\x90a\x0BuV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08yW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08~V[``\x91P[P\x91P\x91Pa\x08\x8E\x82\x82\x86a\x08\x99V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xA8WP\x81a\x07\0V[\x82Q\x15a\x08\xB8W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\n\x91\x90a\x0B\x8BV[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\t\rW__\xFD[PV[\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`Wa\t`a\t\x10V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\x8FWa\t\x8Fa\t\x10V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xAAW__\xFD[\x845a\t\xB5\x81a\x08\xECV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xCC\x81a\x08\xECV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xE7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\t\xF7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x11Wa\n\x11a\t\x10V[a\n$` `\x1F\x19`\x1F\x84\x01\x16\x01a\tfV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n8W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\nmW__\xFD[\x855a\nx\x81a\x08\xECV[\x94P` \x86\x015\x93P`@\x86\x015a\n\x8F\x81a\x08\xECV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xC0W__\xFD[Pa\n\xC9a\t=V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\n\xEEW__\xFD[Pa\n\xF7a\t=V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\x11W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0BPW\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[_` \x82\x84\x03\x12\x15a\x0BfW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\0W__\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\xFE\xA2dipfsX\"\x12 \xEA:\x8D\x8D\x03\xA7\x99\xDE\xBEZ\xF3\x80t\xA1\xC6S\x89f\xE8#\xECG\xA2\xDDfH\x1F<\x94\xF2SxdsolcC\0\x08\x1C\x003a\x01@`@R4\x80\x15a\0\x10W__\xFD[P`@Qa\x0F-8\x03\x80a\x0F-\x839\x81\x01`@\x81\x90Ra\0/\x91a\0sV[`\x01`\x01`\xA0\x1B\x03\x95\x86\x16`\x80R\x93\x85\x16`\xA0R`\xC0\x92\x90\x92R`\xE0R\x82\x16a\x01\0R\x16a\x01 Ra\0\xE3V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0pW__\xFD[PV[______`\xC0\x87\x89\x03\x12\x15a\0\x88W__\xFD[\x86Qa\0\x93\x81a\0\\V[` \x88\x01Q\x90\x96Pa\0\xA4\x81a\0\\V[`@\x88\x01Q``\x89\x01Q`\x80\x8A\x01Q\x92\x97P\x90\x95P\x93Pa\0\xC4\x81a\0\\V[`\xA0\x88\x01Q\x90\x92Pa\0\xD5\x81a\0\\V[\x80\x91PP\x92\x95P\x92\x95P\x92\x95V[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\r\xC6a\x01g_9_\x81\x81a\x01.\x01R\x81\x81a\x04\xFC\x01Ra\x05>\x01R_\x81\x81a\x01U\x01Ra\x03R\x01R_\x81\x81a\x01\xB1\x01Ra\x03\xC1\x01R_\x81\x81a\x01|\x01Ra\x02\x88\x01R_\x81\x81`\xDF\x01R\x81\x81a\x03t\x01Ra\x03\xF0\x01R_\x81\x81`\x8E\x01R\x81\x81a\x02;\x01Ra\x02\xB7\x01Ra\r\xC6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\x85W_5`\xE0\x1C\x80c\xADt}\xE6\x11a\0XW\x80c\xADt}\xE6\x14a\x01)W\x80c\xB9\x93|\xCB\x14a\x01PW\x80c\xC8\xC7\xF7\x01\x14a\x01wW\x80c\xE3L\xEF\x86\x14a\x01\xACW__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0\x89W\x80cN=\xF3\xF4\x14a\0\xDAW\x80cPcL\x0E\x14a\x01\x01W\x80c\x7F\x81O5\x14a\x01\x16W[__\xFD[a\0\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\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\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\x81V[a\x01\x14a\x01\x0F6`\x04a\x0BgV[a\x01\xD3V[\0[a\x01\x14a\x01$6`\x04a\x0C)V[a\x01\xFDV[a\0\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\x81V[a\0\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\x81V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xD1V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\xE8\x91\x90a\x0C\xADV[\x90Pa\x01\xF6\x85\x85\x85\x84a\x01\xFDV[PPPPPV[a\x02\x1Fs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x9AV[a\x02`s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x036\x91\x90a\x0C\xD1V[\x90Pa\x03\x99s\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\x7F\0\0\0\0\0\0\0\0\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\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x82\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04KW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04o\x91\x90a\x0C\xD1V[\x83Q\x90\x91P\x81\x10\x15a\x04\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[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\x85\x83a\x07YV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x06X\x90\x85\x90\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\x90`\x84\x01[`@\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\x07\xB4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF6\x91\x90a\x0C\xD1V[a\x07\0\x91\x90a\x0C\xE8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x06X\x90\x85\x90\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\x90`d\x01a\x05\xF4V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07\xAF\x90\x84\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\x90`d\x01a\x05\xF4V[PPPV[_a\x08\x15\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\x08\xBF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\xAFW\x80\x80` \x01\x90Q\x81\x01\x90a\x083\x91\x90a\r&V[a\x07\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\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\x04\xD9V[``a\x08\xCD\x84\x84_\x85a\x08\xD7V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\tiW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x04\xD9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\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`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x04\xD9V[__\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\n\x0F\x91\x90a\rEV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\nIW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\nNV[``\x91P[P\x91P\x91Pa\n^\x82\x82\x86a\niV[\x97\x96PPPPPPPV[``\x83\x15a\nxWP\x81a\x08\xD0V[\x82Q\x15a\n\x88W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x04\xD9\x91\x90a\r[V[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\xDDW__\xFD[PV[\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\x0B0Wa\x0B0a\n\xE0V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0B_Wa\x0B_a\n\xE0V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0BzW__\xFD[\x845a\x0B\x85\x81a\n\xBCV[\x93P` \x85\x015\x92P`@\x85\x015a\x0B\x9C\x81a\n\xBCV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xB7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\x0B\xC7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xE1Wa\x0B\xE1a\n\xE0V[a\x0B\xF4` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0B6V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0C\x08W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0C=W__\xFD[\x855a\x0CH\x81a\n\xBCV[\x94P` \x86\x015\x93P`@\x86\x015a\x0C_\x81a\n\xBCV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0C\x90W__\xFD[Pa\x0C\x99a\x0B\rV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0C\xBEW__\xFD[Pa\x0C\xC7a\x0B\rV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C\xE1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\r 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[_` \x82\x84\x03\x12\x15a\r6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x08\xD0W__\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\xFE\xA2dipfsX\"\x12 \xD28\x8C\xB3\xDCz\xA6\xF5\xA2\xEBuA}\x11\x05\x9B\xE1<\x8C\x9E\xAB\xE5\xD7\xEA\xDB\x1BV\x1F\x93\x7F\xF6\x91dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 \xBE\xBAcC7\xF2ib\xD3\xA2*^\xDC\x8C)\xAE\xFEz\xB3T\x85\xB7\x1D<\xCC\x01\xFB\xE1.[\xEF\xF6dsolcC\0\x08\x1C\x003", ); #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] @@ -4059,111 +3978,6 @@ event logs(bytes); } } }; - /**Constructor`. -```solidity -constructor(string testFileName, string genesisHexPath, string genesisHeightPath, string periodStartPath); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct constructorCall { - #[allow(missing_docs)] - pub testFileName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub genesisHexPath: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub genesisHeightPath: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub periodStartPath: alloy::sol_types::private::String, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - 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, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - ( - value.testFileName, - value.genesisHexPath, - value.genesisHeightPath, - value.periodStartPath, - ) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - testFileName: tuple.0, - genesisHexPath: tuple.1, - genesisHeightPath: tuple.2, - periodStartPath: tuple.3, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolConstructor for constructorCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.testFileName, - ), - ::tokenize( - &self.genesisHexPath, - ), - ::tokenize( - &self.genesisHeightPath, - ), - ::tokenize( - &self.periodStartPath, - ), - ) - } - } - }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. @@ -5086,31 +4900,17 @@ function failed() external view returns (bool); }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getBlockHeights(string,uint256,uint256)` and selector `0xfad06b8f`. + /**Function with signature `setUp()` and selector `0x0a9254e4`. ```solidity -function getBlockHeights(string memory chainName, uint256 from, uint256 to) external view returns (uint256[] memory elements); +function setUp() external; ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getBlockHeightsCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getBlockHeights(string,uint256,uint256)`](getBlockHeightsCall) function. + pub struct setUpCall; + ///Container type for the return parameters of the [`setUp()`](setUpCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getBlockHeightsReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >, - } + pub struct setUpReturn {} #[allow( non_camel_case_types, non_snake_case, @@ -5121,17 +4921,9 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte use alloy::sol_types as alloy_sol_types; { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - 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::String, - 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( @@ -5145,34 +4937,24 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsCall) -> Self { - (value.chainName, value.from, value.to) + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpCall) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getBlockHeightsCall { + impl ::core::convert::From> for setUpCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } + Self } } } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); + type UnderlyingSolTuple<'a> = (); #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >, - ); + type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -5186,42 +4968,39 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getBlockHeightsReturn) -> Self { - (value.elements,) + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: setUpReturn) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> - for getBlockHeightsReturn { + impl ::core::convert::From> for setUpReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } + Self {} } } } + impl setUpReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } #[automatically_derived] - impl alloy_sol_types::SolCall for getBlockHeightsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); + impl alloy_sol_types::SolCall for setUpCall { + type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); + type Return = setUpReturn; + type ReturnTuple<'a> = (); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getBlockHeights(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [250u8, 208u8, 107u8, 143u8]; + const SIGNATURE: &'static str = "setUp()"; + const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -5230,35 +5009,18 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte } #[inline] fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) + () } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) + setUpReturn::_tokenize(ret) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) + .map(Into::into) } #[inline] fn abi_decode_returns_validate( @@ -5267,40 +5029,32 @@ function getBlockHeights(string memory chainName, uint256 from, uint256 to) exte as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getBlockHeightsReturn = r.into(); - r.elements - }) + .map(Into::into) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getDigestLes(string,uint256,uint256)` and selector `0x44badbb6`. + /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. ```solidity -function getDigestLes(string memory chainName, uint256 from, uint256 to) external view returns (bytes32[] memory elements); +function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getDigestLesCall { + pub struct simulateForkAndTransferCall { #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, + pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, + pub sender: alloy::sol_types::private::Address, #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, + pub receiver: alloy::sol_types::private::Address, + #[allow(missing_docs)] + pub amount: alloy::sol_types::private::primitives::aliases::U256, } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getDigestLes(string,uint256,uint256)`](getDigestLesCall) function. + ///Container type for the return parameters of the [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getDigestLesReturn { - #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >, - } + pub struct simulateForkAndTransferReturn {} #[allow( non_camel_case_types, non_snake_case, @@ -5312,14 +5066,16 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa { #[doc(hidden)] 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::Uint<256>, ); #[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::primitives::aliases::U256, ); #[cfg(test)] @@ -5335,36 +5091,31 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesCall) -> Self { - (value.chainName, value.from, value.to) + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferCall) -> Self { + (value.forkAtBlock, value.sender, value.receiver, value.amount) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getDigestLesCall { + impl ::core::convert::From> + for simulateForkAndTransferCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, + forkAtBlock: tuple.0, + sender: tuple.1, + receiver: tuple.2, + amount: tuple.3, } } } } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array< - alloy::sol_types::sol_data::FixedBytes<32>, - >, - ); + type UnderlyingSolTuple<'a> = (); #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >, - ); + type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -5378,42 +5129,48 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getDigestLesReturn) -> Self { - (value.elements,) + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: simulateForkAndTransferReturn) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getDigestLesReturn { + impl ::core::convert::From> + for simulateForkAndTransferReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } + Self {} } } } + impl simulateForkAndTransferReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken< + '_, + > { + () + } + } #[automatically_derived] - impl alloy_sol_types::SolCall for getDigestLesCall { + impl alloy_sol_types::SolCall for simulateForkAndTransferCall { type Parameters<'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::Uint<256>, ); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::FixedBytes<32>, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array< - alloy::sol_types::sol_data::FixedBytes<32>, - >, - ); + type Return = simulateForkAndTransferReturn; + type ReturnTuple<'a> = (); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getDigestLes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [68u8, 186u8, 219u8, 182u8]; + const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; + const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -5423,22 +5180,176 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - ::tokenize( - &self.chainName, - ), as alloy_sol_types::SolType>::tokenize(&self.from), + > as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), + ::tokenize( + &self.sender, + ), + ::tokenize( + &self.receiver, + ), as alloy_sol_types::SolType>::tokenize(&self.to), + > as alloy_sol_types::SolType>::tokenize(&self.amount), ) } #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + simulateForkAndTransferReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. +```solidity +function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactSelectorsCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct targetArtifactSelectorsReturn { + #[allow(missing_docs)] + pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< + ::RustType, + >, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactSelectorsCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactSelectorsCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec< + ::RustType, + >, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactSelectorsReturn) -> Self { + (value.targetedArtifactSelectors_,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for targetArtifactSelectorsReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { + targetedArtifactSelectors_: tuple.0, + } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + ::RustType, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "targetArtifactSelectors()"; + const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { ( , + StdInvariant::FuzzArtifactSelector, > as alloy_sol_types::SolType>::tokenize(ret), ) } @@ -5448,8 +5359,8 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa '_, > as alloy_sol_types::SolType>::abi_decode_sequence(data) .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ }) } #[inline] @@ -5460,36 +5371,31 @@ function getDigestLes(string memory chainName, uint256 from, uint256 to) externa '_, > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) .map(|r| { - let r: getDigestLesReturn = r.into(); - r.elements + let r: targetArtifactSelectorsReturn = r.into(); + r.targetedArtifactSelectors_ }) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaderHexes(string,uint256,uint256)` and selector `0x0813852a`. + /**Function with signature `targetArtifacts()` and selector `0x85226c81`. ```solidity -function getHeaderHexes(string memory chainName, uint256 from, uint256 to) external view returns (bytes[] memory elements); +function targetArtifacts() external view returns (string[] memory targetedArtifacts_); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getHeaderHexesCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } + pub struct targetArtifactsCall; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaderHexes(string,uint256,uint256)`](getHeaderHexesCall) function. + ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getHeaderHexesReturn { + pub struct targetArtifactsReturn { #[allow(missing_docs)] - pub elements: alloy::sol_types::private::Vec, + pub targetedArtifacts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::String, + >, } #[allow( non_camel_case_types, @@ -5501,17 +5407,9 @@ function getHeaderHexes(string memory chainName, uint256 from, uint256 to) exter use alloy::sol_types as alloy_sol_types; { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - 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::String, - 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( @@ -5525,31 +5423,27 @@ function getHeaderHexes(string memory chainName, uint256 from, uint256 to) exter } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesCall) -> Self { - (value.chainName, value.from, value.to) + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetArtifactsCall) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getHeaderHexesCall { + impl ::core::convert::From> for targetArtifactsCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } + Self } } } { #[doc(hidden)] type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array, ); #[doc(hidden)] type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, + alloy::sol_types::private::Vec, ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] @@ -5564,42 +5458,40 @@ function getHeaderHexes(string memory chainName, uint256 from, uint256 to) exter } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeaderHexesReturn) -> Self { - (value.elements,) + fn from(value: targetArtifactsReturn) -> Self { + (value.targetedArtifacts_,) } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for getHeaderHexesReturn { + for targetArtifactsReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { elements: tuple.0 } + Self { + targetedArtifacts_: tuple.0, + } } } } #[automatically_derived] - impl alloy_sol_types::SolCall for getHeaderHexesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); + impl alloy_sol_types::SolCall for targetArtifactsCall { + type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Bytes, + alloy::sol_types::private::String, >; type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array, ); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaderHexes(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [8u8, 19u8, 133u8, 42u8]; + const SIGNATURE: &'static str = "targetArtifacts()"; + const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -5608,23 +5500,13 @@ function getHeaderHexes(string memory chainName, uint256 from, uint256 to) exter } #[inline] fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) + () } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { ( as alloy_sol_types::SolType>::tokenize(ret), ) } @@ -5634,8 +5516,8 @@ function getHeaderHexes(string memory chainName, uint256 from, uint256 to) exter '_, > as alloy_sol_types::SolType>::abi_decode_sequence(data) .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ }) } #[inline] @@ -5646,36 +5528,31 @@ function getHeaderHexes(string memory chainName, uint256 from, uint256 to) exter '_, > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) .map(|r| { - let r: getHeaderHexesReturn = r.into(); - r.elements + let r: targetArtifactsReturn = r.into(); + r.targetedArtifacts_ }) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getHeaders(string,uint256,uint256)` and selector `0x1c0da81f`. + /**Function with signature `targetContracts()` and selector `0x3f7286f4`. ```solidity -function getHeaders(string memory chainName, uint256 from, uint256 to) external view returns (bytes memory headers); +function targetContracts() external view returns (address[] memory targetedContracts_); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getHeadersCall { - #[allow(missing_docs)] - pub chainName: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub from: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub to: alloy::sol_types::private::primitives::aliases::U256, - } + pub struct targetContractsCall; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getHeaders(string,uint256,uint256)`](getHeadersCall) function. + ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct getHeadersReturn { + pub struct targetContractsReturn { #[allow(missing_docs)] - pub headers: alloy::sol_types::private::Bytes, + pub targetedContracts_: alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >, } #[allow( non_camel_case_types, @@ -5684,20 +5561,12 @@ function getHeaders(string memory chainName, uint256 from, uint256 to) external clippy::style )] const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); + use alloy::sol_types as alloy_sol_types; + { #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::primitives::aliases::U256, - alloy::sol_types::private::primitives::aliases::U256, - ); + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -5711,28 +5580,28 @@ function getHeaders(string memory chainName, uint256 from, uint256 to) external } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersCall) -> Self { - (value.chainName, value.from, value.to) + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetContractsCall) -> Self { + () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getHeadersCall { + impl ::core::convert::From> for targetContractsCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - chainName: tuple.0, - from: tuple.1, - to: tuple.2, - } + Self } } } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Bytes,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -5746,36 +5615,40 @@ function getHeaders(string memory chainName, uint256 from, uint256 to) external } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getHeadersReturn) -> Self { - (value.headers,) + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: targetContractsReturn) -> Self { + (value.targetedContracts_,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getHeadersReturn { + impl ::core::convert::From> + for targetContractsReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { headers: tuple.0 } + Self { + targetedContracts_: tuple.0, + } } } } #[automatically_derived] - impl alloy_sol_types::SolCall for getHeadersCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); + impl alloy_sol_types::SolCall for targetContractsCall { + type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Bytes; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getHeaders(string,uint256,uint256)"; - const SELECTOR: [u8; 4] = [28u8, 13u8, 168u8, 31u8]; + const SIGNATURE: &'static str = "targetContracts()"; + const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -5784,24 +5657,14 @@ function getHeaders(string memory chainName, uint256 from, uint256 to) external } #[inline] fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.chainName, - ), - as alloy_sol_types::SolType>::tokenize(&self.from), - as alloy_sol_types::SolType>::tokenize(&self.to), - ) + () } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { ( - ::tokenize( - ret, - ), + as alloy_sol_types::SolType>::tokenize(ret), ) } #[inline] @@ -5810,8 +5673,8 @@ function getHeaders(string memory chainName, uint256 from, uint256 to) external '_, > as alloy_sol_types::SolType>::abi_decode_sequence(data) .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers + let r: targetContractsReturn = r.into(); + r.targetedContracts_ }) } #[inline] @@ -5822,30 +5685,30 @@ function getHeaders(string memory chainName, uint256 from, uint256 to) external '_, > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) .map(|r| { - let r: getHeadersReturn = r.into(); - r.headers + let r: targetContractsReturn = r.into(); + r.targetedContracts_ }) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. + /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. ```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); +function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetArtifactSelectorsCall; + pub struct targetInterfacesCall; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. + ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { + pub struct targetInterfacesReturn { #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, + pub targetedInterfaces_: alloy::sol_types::private::Vec< + ::RustType, >, } #[allow( @@ -5874,16 +5737,16 @@ function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtif } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { + fn from(value: targetInterfacesCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for targetArtifactSelectorsCall { + for targetInterfacesCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -5892,12 +5755,12 @@ function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtif { #[doc(hidden)] type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array, ); #[doc(hidden)] type UnderlyingRustTuple<'a> = ( alloy::sol_types::private::Vec< - ::RustType, + ::RustType, >, ); #[cfg(test)] @@ -5913,40 +5776,40 @@ function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtif } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) + fn from(value: targetInterfacesReturn) -> Self { + (value.targetedInterfaces_,) } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for targetArtifactSelectorsReturn { + for targetInterfacesReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { - targetedArtifactSelectors_: tuple.0, + targetedInterfaces_: tuple.0, } } } } #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { + impl alloy_sol_types::SolCall for targetInterfacesCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = alloy::sol_types::private::Vec< - ::RustType, + ::RustType, >; type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array, ); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; + const SIGNATURE: &'static str = "targetInterfaces()"; + const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -5961,7 +5824,7 @@ function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtif fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { ( as alloy_sol_types::SolType>::tokenize(ret), ) } @@ -5971,8 +5834,8 @@ function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtif '_, > as alloy_sol_types::SolType>::abi_decode_sequence(data) .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ }) } #[inline] @@ -5983,30 +5846,30 @@ function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtif '_, > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ + let r: targetInterfacesReturn = r.into(); + r.targetedInterfaces_ }) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. + /**Function with signature `targetSelectors()` and selector `0x916a17c6`. ```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); +function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetArtifactsCall; + pub struct targetSelectorsCall; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. + ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetArtifactsReturn { + pub struct targetSelectorsReturn { #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, + pub targetedSelectors_: alloy::sol_types::private::Vec< + ::RustType, >, } #[allow( @@ -6035,14 +5898,14 @@ function targetArtifacts() external view returns (string[] memory targetedArtifa } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSelectorsCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { + impl ::core::convert::From> for targetSelectorsCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -6051,11 +5914,13 @@ function targetArtifacts() external view returns (string[] memory targetedArtifa { #[doc(hidden)] type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array, ); #[doc(hidden)] type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, + alloy::sol_types::private::Vec< + ::RustType, + >, ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] @@ -6070,40 +5935,40 @@ function targetArtifacts() external view returns (string[] memory targetedArtifa } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) + fn from(value: targetSelectorsReturn) -> Self { + (value.targetedSelectors_,) } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for targetArtifactsReturn { + for targetSelectorsReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { - targetedArtifacts_: tuple.0, + targetedSelectors_: tuple.0, } } } } #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { + impl alloy_sol_types::SolCall for targetSelectorsCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, + ::RustType, >; type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, + alloy::sol_types::sol_data::Array, ); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; + const SIGNATURE: &'static str = "targetSelectors()"; + const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -6118,7 +5983,7 @@ function targetArtifacts() external view returns (string[] memory targetedArtifa fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { ( as alloy_sol_types::SolType>::tokenize(ret), ) } @@ -6128,8 +5993,8 @@ function targetArtifacts() external view returns (string[] memory targetedArtifa '_, > as alloy_sol_types::SolType>::abi_decode_sequence(data) .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ }) } #[inline] @@ -6140,29 +6005,29 @@ function targetArtifacts() external view returns (string[] memory targetedArtifa '_, > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ + let r: targetSelectorsReturn = r.into(); + r.targetedSelectors_ }) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. + /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. ```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); +function targetSenders() external view returns (address[] memory targetedSenders_); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetContractsCall; + pub struct targetSendersCall; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. + ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetContractsReturn { + pub struct targetSendersReturn { #[allow(missing_docs)] - pub targetedContracts_: alloy::sol_types::private::Vec< + pub targetedSenders_: alloy::sol_types::private::Vec< alloy::sol_types::private::Address, >, } @@ -6192,14 +6057,14 @@ function targetContracts() external view returns (address[] memory targetedContr } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { + impl ::core::convert::From> for targetSendersCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -6227,25 +6092,21 @@ function targetContracts() external view returns (address[] memory targetedContr } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: targetSendersReturn) -> Self { + (value.targetedSenders_,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { + impl ::core::convert::From> for targetSendersReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } + Self { targetedSenders_: tuple.0 } } } } #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { + impl alloy_sol_types::SolCall for targetSendersCall { type Parameters<'a> = (); type Token<'a> = = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; + const SIGNATURE: &'static str = "targetSenders()"; + const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -6285,8 +6146,8 @@ function targetContracts() external view returns (address[] memory targetedContr '_, > as alloy_sol_types::SolType>::abi_decode_sequence(data) .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ + let r: targetSendersReturn = r.into(); + r.targetedSenders_ }) } #[inline] @@ -6297,32 +6158,25 @@ function targetContracts() external view returns (address[] memory targetedContr '_, > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ + let r: targetSendersReturn = r.into(); + r.targetedSenders_ }) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. + /**Function with signature `testSolvBTCStrategy()` and selector `0x7eec06b2`. ```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); +function testSolvBTCStrategy() external; ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. + pub struct testSolvBTCStrategyCall; + ///Container type for the return parameters of the [`testSolvBTCStrategy()`](testSolvBTCStrategyCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } + pub struct testSolvBTCStrategyReturn {} #[allow( non_camel_case_types, non_snake_case, @@ -6349,16 +6203,16 @@ function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { + fn from(value: testSolvBTCStrategyCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for targetInterfacesCall { + for testSolvBTCStrategyCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -6366,15 +6220,9 @@ function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); + type UnderlyingSolTuple<'a> = (); #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); + type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -6388,40 +6236,41 @@ function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) + fn from(value: testSolvBTCStrategyReturn) -> Self { + () } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } + for testSolvBTCStrategyReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} } } } + impl testSolvBTCStrategyReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { + impl alloy_sol_types::SolCall for testSolvBTCStrategyCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); + type Return = testSolvBTCStrategyReturn; + type ReturnTuple<'a> = (); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; + const SIGNATURE: &'static str = "testSolvBTCStrategy()"; + const SELECTOR: [u8; 4] = [126u8, 236u8, 6u8, 178u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -6434,21 +6283,14 @@ function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) + testSolvBTCStrategyReturn::_tokenize(ret) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) + .map(Into::into) } #[inline] fn abi_decode_returns_validate( @@ -6457,33 +6299,23 @@ function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) + .map(Into::into) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. + /**Function with signature `testSolvLSTStrategy()` and selector `0xf7f08cfb`. ```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); +function testSolvLSTStrategy() external; ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. + pub struct testSolvLSTStrategyCall; + ///Container type for the return parameters of the [`testSolvLSTStrategy()`](testSolvLSTStrategyCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } + pub struct testSolvLSTStrategyReturn {} #[allow( non_camel_case_types, non_snake_case, @@ -6510,14 +6342,16 @@ function targetSelectors() external view returns (StdInvariant.FuzzSelector[] me } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: testSolvLSTStrategyCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { + impl ::core::convert::From> + for testSolvLSTStrategyCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -6525,15 +6359,9 @@ function targetSelectors() external view returns (StdInvariant.FuzzSelector[] me } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); + type UnderlyingSolTuple<'a> = (); #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); + type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -6547,40 +6375,41 @@ function targetSelectors() external view returns (StdInvariant.FuzzSelector[] me } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From + impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) + fn from(value: testSolvLSTStrategyReturn) -> Self { + () } } #[automatically_derived] #[doc(hidden)] impl ::core::convert::From> - for targetSelectorsReturn { + for testSolvLSTStrategyReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } + Self {} } } } + impl testSolvLSTStrategyReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { + impl alloy_sol_types::SolCall for testSolvLSTStrategyCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); + type Return = testSolvLSTStrategyReturn; + type ReturnTuple<'a> = (); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; + const SIGNATURE: &'static str = "testSolvLSTStrategy()"; + const SELECTOR: [u8; 4] = [247u8, 240u8, 140u8, 251u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -6593,21 +6422,14 @@ function targetSelectors() external view returns (StdInvariant.FuzzSelector[] me } #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) + testSolvLSTStrategyReturn::_tokenize(ret) } #[inline] fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) + .map(Into::into) } #[inline] fn abi_decode_returns_validate( @@ -6616,32 +6438,27 @@ function targetSelectors() external view returns (StdInvariant.FuzzSelector[] me as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) + .map(Into::into) } } }; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. + /**Function with signature `token()` and selector `0xfc0c546a`. ```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); +function token() external view returns (address); ```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetSendersCall; + pub struct tokenCall; #[derive(serde::Serialize, serde::Deserialize)] #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. + ///Container type for the return parameters of the [`token()`](tokenCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] - pub struct targetSendersReturn { + pub struct tokenReturn { #[allow(missing_docs)] - pub targetedSenders_: alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >, + pub _0: alloy::sol_types::private::Address, } #[allow( non_camel_case_types, @@ -6669,14 +6486,14 @@ function targetSenders() external view returns (address[] memory targetedSenders } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { + impl ::core::convert::From> for tokenCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self } @@ -6684,13 +6501,9 @@ function targetSenders() external view returns (address[] memory targetedSenders } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] fn _type_assertion( @@ -6704,36 +6517,32 @@ function targetSenders() external view returns (address[] memory targetedSenders } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: tokenReturn) -> Self { + (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { + impl ::core::convert::From> for tokenReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } + Self { _0: tuple.0 } } } } #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { + impl alloy_sol_types::SolCall for tokenCall { type Parameters<'a> = (); type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; + const SIGNATURE: &'static str = "token()"; + const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -6747,9 +6556,9 @@ function targetSenders() external view returns (address[] memory targetedSenders #[inline] fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { ( - as alloy_sol_types::SolType>::tokenize(ret), + ::tokenize( + ret, + ), ) } #[inline] @@ -6758,8 +6567,8 @@ function targetSenders() external view returns (address[] memory targetedSenders '_, > as alloy_sol_types::SolType>::abi_decode_sequence(data) .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ + let r: tokenReturn = r.into(); + r._0 }) } #[inline] @@ -6770,16 +6579,16 @@ function targetSenders() external view returns (address[] memory targetedSenders '_, > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ + let r: tokenReturn = r.into(); + r._0 }) } } }; - ///Container for all the [`FullRelayTestUtils`](self) function calls. + ///Container for all the [`SolvStrategyForked`](self) function calls. #[derive(serde::Serialize, serde::Deserialize)] #[derive()] - pub enum FullRelayTestUtilsCalls { + pub enum SolvStrategyForkedCalls { #[allow(missing_docs)] IS_TEST(IS_TESTCall), #[allow(missing_docs)] @@ -6793,13 +6602,9 @@ function targetSenders() external view returns (address[] memory targetedSenders #[allow(missing_docs)] failed(failedCall), #[allow(missing_docs)] - getBlockHeights(getBlockHeightsCall), - #[allow(missing_docs)] - getDigestLes(getDigestLesCall), - #[allow(missing_docs)] - getHeaderHexes(getHeaderHexesCall), + setUp(setUpCall), #[allow(missing_docs)] - getHeaders(getHeadersCall), + simulateForkAndTransfer(simulateForkAndTransferCall), #[allow(missing_docs)] targetArtifactSelectors(targetArtifactSelectorsCall), #[allow(missing_docs)] @@ -6812,9 +6617,15 @@ function targetSenders() external view returns (address[] memory targetedSenders targetSelectors(targetSelectorsCall), #[allow(missing_docs)] targetSenders(targetSendersCall), + #[allow(missing_docs)] + testSolvBTCStrategy(testSolvBTCStrategyCall), + #[allow(missing_docs)] + testSolvLSTStrategy(testSolvLSTStrategyCall), + #[allow(missing_docs)] + token(tokenCall), } #[automatically_derived] - impl FullRelayTestUtilsCalls { + impl SolvStrategyForkedCalls { /// All the selectors of this enum. /// /// Note that the selectors might not be in the same order as the variants. @@ -6822,29 +6633,30 @@ function targetSenders() external view returns (address[] memory targetedSenders /// /// Prefer using `SolInterface` methods instead. pub const SELECTORS: &'static [[u8; 4usize]] = &[ - [8u8, 19u8, 133u8, 42u8], - [28u8, 13u8, 168u8, 31u8], + [10u8, 146u8, 84u8, 228u8], [30u8, 215u8, 131u8, 28u8], [42u8, 222u8, 56u8, 128u8], [62u8, 94u8, 60u8, 35u8], [63u8, 114u8, 134u8, 244u8], - [68u8, 186u8, 219u8, 182u8], [102u8, 217u8, 169u8, 160u8], + [126u8, 236u8, 6u8, 178u8], [133u8, 34u8, 108u8, 129u8], [145u8, 106u8, 23u8, 198u8], [176u8, 70u8, 79u8, 220u8], [181u8, 80u8, 138u8, 169u8], [186u8, 65u8, 79u8, 166u8], [226u8, 12u8, 159u8, 113u8], + [247u8, 240u8, 140u8, 251u8], + [249u8, 206u8, 14u8, 90u8], [250u8, 118u8, 38u8, 212u8], - [250u8, 208u8, 107u8, 143u8], + [252u8, 12u8, 84u8, 106u8], ]; } #[automatically_derived] - impl alloy_sol_types::SolInterface for FullRelayTestUtilsCalls { - const NAME: &'static str = "FullRelayTestUtilsCalls"; + impl alloy_sol_types::SolInterface for SolvStrategyForkedCalls { + const NAME: &'static str = "SolvStrategyForkedCalls"; const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 16usize; + const COUNT: usize = 17usize; #[inline] fn selector(&self) -> [u8; 4] { match self { @@ -6862,17 +6674,9 @@ function targetSenders() external view returns (address[] memory targetedSenders ::SELECTOR } Self::failed(_) => ::SELECTOR, - Self::getBlockHeights(_) => { - ::SELECTOR - } - Self::getDigestLes(_) => { - ::SELECTOR - } - Self::getHeaderHexes(_) => { - ::SELECTOR - } - Self::getHeaders(_) => { - ::SELECTOR + Self::setUp(_) => ::SELECTOR, + Self::simulateForkAndTransfer(_) => { + ::SELECTOR } Self::targetArtifactSelectors(_) => { ::SELECTOR @@ -6892,6 +6696,13 @@ function targetSenders() external view returns (address[] memory targetedSenders Self::targetSenders(_) => { ::SELECTOR } + Self::testSolvBTCStrategy(_) => { + ::SELECTOR + } + Self::testSolvLSTStrategy(_) => { + ::SELECTOR + } + Self::token(_) => ::SELECTOR, } } #[inline] @@ -6910,178 +6721,185 @@ function targetSenders() external view returns (address[] memory targetedSenders ) -> alloy_sol_types::Result { static DECODE_SHIMS: &[fn( &[u8], - ) -> alloy_sol_types::Result] = &[ + ) -> alloy_sol_types::Result] = &[ { - fn getHeaderHexes( + fn setUp( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayTestUtilsCalls::getHeaderHexes) - } - getHeaderHexes - }, - { - fn getHeaders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayTestUtilsCalls::getHeaders) + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(SolvStrategyForkedCalls::setUp) } - getHeaders + setUp }, { fn excludeSenders( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayTestUtilsCalls::excludeSenders) + .map(SolvStrategyForkedCalls::excludeSenders) } excludeSenders }, { fn targetInterfaces( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayTestUtilsCalls::targetInterfaces) + .map(SolvStrategyForkedCalls::targetInterfaces) } targetInterfaces }, { fn targetSenders( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayTestUtilsCalls::targetSenders) + .map(SolvStrategyForkedCalls::targetSenders) } targetSenders }, { fn targetContracts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayTestUtilsCalls::targetContracts) + .map(SolvStrategyForkedCalls::targetContracts) } targetContracts }, { - fn getDigestLes( + fn targetArtifactSelectors( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( + ) -> alloy_sol_types::Result { + ::abi_decode_raw( data, ) - .map(FullRelayTestUtilsCalls::getDigestLes) + .map(SolvStrategyForkedCalls::targetArtifactSelectors) } - getDigestLes + targetArtifactSelectors }, { - fn targetArtifactSelectors( + fn testSolvBTCStrategy( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( + ) -> alloy_sol_types::Result { + ::abi_decode_raw( data, ) - .map(FullRelayTestUtilsCalls::targetArtifactSelectors) + .map(SolvStrategyForkedCalls::testSolvBTCStrategy) } - targetArtifactSelectors + testSolvBTCStrategy }, { fn targetArtifacts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayTestUtilsCalls::targetArtifacts) + .map(SolvStrategyForkedCalls::targetArtifacts) } targetArtifacts }, { fn targetSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayTestUtilsCalls::targetSelectors) + .map(SolvStrategyForkedCalls::targetSelectors) } targetSelectors }, { fn excludeSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayTestUtilsCalls::excludeSelectors) + .map(SolvStrategyForkedCalls::excludeSelectors) } excludeSelectors }, { fn excludeArtifacts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayTestUtilsCalls::excludeArtifacts) + .map(SolvStrategyForkedCalls::excludeArtifacts) } excludeArtifacts }, { fn failed( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw(data) - .map(FullRelayTestUtilsCalls::failed) + .map(SolvStrategyForkedCalls::failed) } failed }, { fn excludeContracts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw( data, ) - .map(FullRelayTestUtilsCalls::excludeContracts) + .map(SolvStrategyForkedCalls::excludeContracts) } excludeContracts }, + { + fn testSolvLSTStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SolvStrategyForkedCalls::testSolvLSTStrategy) + } + testSolvLSTStrategy + }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(SolvStrategyForkedCalls::simulateForkAndTransfer) + } + simulateForkAndTransfer + }, { fn IS_TEST( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw(data) - .map(FullRelayTestUtilsCalls::IS_TEST) + .map(SolvStrategyForkedCalls::IS_TEST) } IS_TEST }, { - fn getBlockHeights( + fn token( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(FullRelayTestUtilsCalls::getBlockHeights) + ) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(SolvStrategyForkedCalls::token) } - getBlockHeights + token }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { @@ -7102,182 +6920,193 @@ function targetSenders() external view returns (address[] memory targetedSenders ) -> alloy_sol_types::Result { static DECODE_VALIDATE_SHIMS: &[fn( &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getHeaderHexes( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(FullRelayTestUtilsCalls::getHeaderHexes) - } - getHeaderHexes - }, + ) -> alloy_sol_types::Result] = &[ { - fn getHeaders( + fn setUp( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( data, ) - .map(FullRelayTestUtilsCalls::getHeaders) + .map(SolvStrategyForkedCalls::setUp) } - getHeaders + setUp }, { fn excludeSenders( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayTestUtilsCalls::excludeSenders) + .map(SolvStrategyForkedCalls::excludeSenders) } excludeSenders }, { fn targetInterfaces( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayTestUtilsCalls::targetInterfaces) + .map(SolvStrategyForkedCalls::targetInterfaces) } targetInterfaces }, { fn targetSenders( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayTestUtilsCalls::targetSenders) + .map(SolvStrategyForkedCalls::targetSenders) } targetSenders }, { fn targetContracts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayTestUtilsCalls::targetContracts) + .map(SolvStrategyForkedCalls::targetContracts) } targetContracts }, { - fn getDigestLes( + fn targetArtifactSelectors( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( data, ) - .map(FullRelayTestUtilsCalls::getDigestLes) + .map(SolvStrategyForkedCalls::targetArtifactSelectors) } - getDigestLes + targetArtifactSelectors }, { - fn targetArtifactSelectors( + fn testSolvBTCStrategy( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( data, ) - .map(FullRelayTestUtilsCalls::targetArtifactSelectors) + .map(SolvStrategyForkedCalls::testSolvBTCStrategy) } - targetArtifactSelectors + testSolvBTCStrategy }, { fn targetArtifacts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayTestUtilsCalls::targetArtifacts) + .map(SolvStrategyForkedCalls::targetArtifacts) } targetArtifacts }, { fn targetSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayTestUtilsCalls::targetSelectors) + .map(SolvStrategyForkedCalls::targetSelectors) } targetSelectors }, { fn excludeSelectors( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayTestUtilsCalls::excludeSelectors) + .map(SolvStrategyForkedCalls::excludeSelectors) } excludeSelectors }, { fn excludeArtifacts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayTestUtilsCalls::excludeArtifacts) + .map(SolvStrategyForkedCalls::excludeArtifacts) } excludeArtifacts }, { fn failed( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayTestUtilsCalls::failed) + .map(SolvStrategyForkedCalls::failed) } failed }, { fn excludeContracts( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayTestUtilsCalls::excludeContracts) + .map(SolvStrategyForkedCalls::excludeContracts) } excludeContracts }, + { + fn testSolvLSTStrategy( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SolvStrategyForkedCalls::testSolvLSTStrategy) + } + testSolvLSTStrategy + }, + { + fn simulateForkAndTransfer( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(SolvStrategyForkedCalls::simulateForkAndTransfer) + } + simulateForkAndTransfer + }, { fn IS_TEST( data: &[u8], - ) -> alloy_sol_types::Result { + ) -> alloy_sol_types::Result { ::abi_decode_raw_validate( data, ) - .map(FullRelayTestUtilsCalls::IS_TEST) + .map(SolvStrategyForkedCalls::IS_TEST) } IS_TEST }, { - fn getBlockHeights( + fn token( data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( data, ) - .map(FullRelayTestUtilsCalls::getBlockHeights) + .map(SolvStrategyForkedCalls::token) } - getBlockHeights + token }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { @@ -7319,24 +7148,14 @@ function targetSenders() external view returns (address[] memory targetedSenders Self::failed(inner) => { ::abi_encoded_size(inner) } - Self::getBlockHeights(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getDigestLes(inner) => { - ::abi_encoded_size( - inner, - ) + Self::setUp(inner) => { + ::abi_encoded_size(inner) } - Self::getHeaderHexes(inner) => { - ::abi_encoded_size( + Self::simulateForkAndTransfer(inner) => { + ::abi_encoded_size( inner, ) } - Self::getHeaders(inner) => { - ::abi_encoded_size(inner) - } Self::targetArtifactSelectors(inner) => { ::abi_encoded_size( inner, @@ -7367,6 +7186,19 @@ function targetSenders() external view returns (address[] memory targetedSenders inner, ) } + Self::testSolvBTCStrategy(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::testSolvLSTStrategy(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::token(inner) => { + ::abi_encoded_size(inner) + } } } #[inline] @@ -7402,26 +7234,11 @@ function targetSenders() external view returns (address[] memory targetedSenders Self::failed(inner) => { ::abi_encode_raw(inner, out) } - Self::getBlockHeights(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getDigestLes(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getHeaderHexes(inner) => { - ::abi_encode_raw( - inner, - out, - ) + Self::setUp(inner) => { + ::abi_encode_raw(inner, out) } - Self::getHeaders(inner) => { - ::abi_encode_raw( + Self::simulateForkAndTransfer(inner) => { + ::abi_encode_raw( inner, out, ) @@ -7462,13 +7279,28 @@ function targetSenders() external view returns (address[] memory targetedSenders out, ) } + Self::testSolvBTCStrategy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::testSolvLSTStrategy(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::token(inner) => { + ::abi_encode_raw(inner, out) + } } } } - ///Container for all the [`FullRelayTestUtils`](self) events. + ///Container for all the [`SolvStrategyForked`](self) events. #[derive(serde::Serialize, serde::Deserialize)] #[derive()] - pub enum FullRelayTestUtilsEvents { + pub enum SolvStrategyForkedEvents { #[allow(missing_docs)] log(log), #[allow(missing_docs)] @@ -7515,7 +7347,7 @@ function targetSenders() external view returns (address[] memory targetedSenders logs(logs), } #[automatically_derived] - impl FullRelayTestUtilsEvents { + impl SolvStrategyForkedEvents { /// All the selectors of this enum. /// /// Note that the selectors might not be in the same order as the variants. @@ -7636,8 +7468,8 @@ function targetSenders() external view returns (address[] memory targetedSenders ]; } #[automatically_derived] - impl alloy_sol_types::SolEventInterface for FullRelayTestUtilsEvents { - const NAME: &'static str = "FullRelayTestUtilsEvents"; + impl alloy_sol_types::SolEventInterface for SolvStrategyForkedEvents { + const NAME: &'static str = "SolvStrategyForkedEvents"; const COUNT: usize = 22usize; fn decode_raw_log( topics: &[alloy_sol_types::Word], @@ -7815,7 +7647,7 @@ function targetSenders() external view returns (address[] memory targetedSenders } } #[automatically_derived] - impl alloy_sol_types::private::IntoLogData for FullRelayTestUtilsEvents { + impl alloy_sol_types::private::IntoLogData for SolvStrategyForkedEvents { fn to_log_data(&self) -> alloy_sol_types::private::LogData { match self { Self::log(inner) => { @@ -7958,9 +7790,9 @@ function targetSenders() external view returns (address[] memory targetedSenders } } use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`FullRelayTestUtils`](self) contract instance. + /**Creates a new wrapper around an on-chain [`SolvStrategyForked`](self) contract instance. -See the [wrapper's documentation](`FullRelayTestUtilsInstance`) for more details.*/ +See the [wrapper's documentation](`SolvStrategyForkedInstance`) for more details.*/ #[inline] pub const fn new< P: alloy_contract::private::Provider, @@ -7968,8 +7800,8 @@ See the [wrapper's documentation](`FullRelayTestUtilsInstance`) for more details >( address: alloy_sol_types::private::Address, provider: P, - ) -> FullRelayTestUtilsInstance { - FullRelayTestUtilsInstance::::new(address, provider) + ) -> SolvStrategyForkedInstance { + SolvStrategyForkedInstance::::new(address, provider) } /**Deploys this contract using the given `provider` and constructor arguments, if any. @@ -7982,23 +7814,10 @@ For more fine-grained control over the deployment process, use [`deploy_builder` N: alloy_contract::private::Network, >( provider: P, - testFileName: alloy::sol_types::private::String, - genesisHexPath: alloy::sol_types::private::String, - genesisHeightPath: alloy::sol_types::private::String, - periodStartPath: alloy::sol_types::private::String, ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, + Output = alloy_contract::Result>, > { - FullRelayTestUtilsInstance::< - P, - N, - >::deploy( - provider, - testFileName, - genesisHexPath, - genesisHeightPath, - periodStartPath, - ) + SolvStrategyForkedInstance::::deploy(provider) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` and constructor arguments, if any. @@ -8009,28 +7828,13 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ pub fn deploy_builder< P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - >( - provider: P, - testFileName: alloy::sol_types::private::String, - genesisHexPath: alloy::sol_types::private::String, - genesisHeightPath: alloy::sol_types::private::String, - periodStartPath: alloy::sol_types::private::String, - ) -> alloy_contract::RawCallBuilder { - FullRelayTestUtilsInstance::< - P, - N, - >::deploy_builder( - provider, - testFileName, - genesisHexPath, - genesisHeightPath, - periodStartPath, - ) + >(provider: P) -> alloy_contract::RawCallBuilder { + SolvStrategyForkedInstance::::deploy_builder(provider) } - /**A [`FullRelayTestUtils`](self) instance. + /**A [`SolvStrategyForked`](self) instance. Contains type-safe methods for interacting with an on-chain instance of the -[`FullRelayTestUtils`](self) contract located at a given `address`, using a given +[`SolvStrategyForked`](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!) @@ -8039,16 +7843,16 @@ 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 FullRelayTestUtilsInstance { + pub struct SolvStrategyForkedInstance { address: alloy_sol_types::private::Address, provider: P, _network: ::core::marker::PhantomData, } #[automatically_derived] - impl ::core::fmt::Debug for FullRelayTestUtilsInstance { + impl ::core::fmt::Debug for SolvStrategyForkedInstance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("FullRelayTestUtilsInstance").field(&self.address).finish() + f.debug_tuple("SolvStrategyForkedInstance").field(&self.address).finish() } } /// Instantiation and getters/setters. @@ -8056,10 +7860,10 @@ See the [module-level documentation](self) for all the available methods.*/ impl< P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - > FullRelayTestUtilsInstance { - /**Creates a new wrapper around an on-chain [`FullRelayTestUtils`](self) contract instance. + > SolvStrategyForkedInstance { + /**Creates a new wrapper around an on-chain [`SolvStrategyForked`](self) contract instance. -See the [wrapper's documentation](`FullRelayTestUtilsInstance`) for more details.*/ +See the [wrapper's documentation](`SolvStrategyForkedInstance`) for more details.*/ #[inline] pub const fn new( address: alloy_sol_types::private::Address, @@ -8079,18 +7883,8 @@ For more fine-grained control over the deployment process, use [`deploy_builder` #[inline] pub async fn deploy( provider: P, - testFileName: alloy::sol_types::private::String, - genesisHexPath: alloy::sol_types::private::String, - genesisHeightPath: alloy::sol_types::private::String, - periodStartPath: alloy::sol_types::private::String, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder( - provider, - testFileName, - genesisHexPath, - genesisHeightPath, - periodStartPath, - ); + ) -> alloy_contract::Result> { + let call_builder = Self::deploy_builder(provider); let contract_address = call_builder.deploy().await?; Ok(Self::new(contract_address, call_builder.provider)) } @@ -8100,28 +7894,10 @@ 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, - testFileName: alloy::sol_types::private::String, - genesisHexPath: alloy::sol_types::private::String, - genesisHeightPath: alloy::sol_types::private::String, - periodStartPath: alloy::sol_types::private::String, - ) -> alloy_contract::RawCallBuilder { + pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder { alloy_contract::RawCallBuilder::new_raw_deploy( provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { - testFileName, - genesisHexPath, - genesisHeightPath, - periodStartPath, - }, - )[..], - ] - .concat() - .into(), + ::core::clone::Clone::clone(&BYTECODE), ) } /// Returns a reference to the address. @@ -8145,11 +7921,11 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ &self.provider } } - impl FullRelayTestUtilsInstance<&P, N> { + impl SolvStrategyForkedInstance<&P, N> { /// Clones the provider and returns a new instance with the cloned provider. #[inline] - pub fn with_cloned_provider(self) -> FullRelayTestUtilsInstance { - FullRelayTestUtilsInstance { + pub fn with_cloned_provider(self) -> SolvStrategyForkedInstance { + SolvStrategyForkedInstance { address: self.address, provider: ::core::clone::Clone::clone(&self.provider), _network: ::core::marker::PhantomData, @@ -8161,7 +7937,7 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ impl< P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - > FullRelayTestUtilsInstance { + > SolvStrategyForkedInstance { /// 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 @@ -8204,63 +7980,24 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { self.call_builder(&failedCall) } - ///Creates a new call builder for the [`getBlockHeights`] function. - pub fn getBlockHeights( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getBlockHeightsCall, N> { - self.call_builder( - &getBlockHeightsCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getDigestLes`] function. - pub fn getDigestLes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getDigestLesCall, N> { - self.call_builder( - &getDigestLesCall { - chainName, - from, - to, - }, - ) - } - ///Creates a new call builder for the [`getHeaderHexes`] function. - pub fn getHeaderHexes( - &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeaderHexesCall, N> { - self.call_builder( - &getHeaderHexesCall { - chainName, - from, - to, - }, - ) + ///Creates a new call builder for the [`setUp`] function. + pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { + self.call_builder(&setUpCall) } - ///Creates a new call builder for the [`getHeaders`] function. - pub fn getHeaders( + ///Creates a new call builder for the [`simulateForkAndTransfer`] function. + pub fn simulateForkAndTransfer( &self, - chainName: alloy::sol_types::private::String, - from: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getHeadersCall, N> { + forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, + sender: alloy::sol_types::private::Address, + receiver: alloy::sol_types::private::Address, + amount: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { self.call_builder( - &getHeadersCall { - chainName, - from, - to, + &simulateForkAndTransferCall { + forkAtBlock, + sender, + receiver, + amount, }, ) } @@ -8300,13 +8037,29 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/ ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { self.call_builder(&targetSendersCall) } + ///Creates a new call builder for the [`testSolvBTCStrategy`] function. + pub fn testSolvBTCStrategy( + &self, + ) -> alloy_contract::SolCallBuilder<&P, testSolvBTCStrategyCall, N> { + self.call_builder(&testSolvBTCStrategyCall) + } + ///Creates a new call builder for the [`testSolvLSTStrategy`] function. + pub fn testSolvLSTStrategy( + &self, + ) -> alloy_contract::SolCallBuilder<&P, testSolvLSTStrategyCall, N> { + self.call_builder(&testSolvLSTStrategyCall) + } + ///Creates a new call builder for the [`token`] function. + pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { + self.call_builder(&tokenCall) + } } /// Event filters. #[automatically_derived] impl< P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - > FullRelayTestUtilsInstance { + > SolvStrategyForkedInstance { /// 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. diff --git a/crates/bindings/src/std_constants.rs b/crates/bindings/src/std_constants.rs new file mode 100644 index 000000000..795031119 --- /dev/null +++ b/crates/bindings/src/std_constants.rs @@ -0,0 +1,218 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface StdConstants {} +``` + +...which was generated by the following JSON ABI: +```json +[] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod StdConstants { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212207bd4df70c18f4df42840c49b2e801fd97f3ffafa3607a730693555f9ea229b4264736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`U`2`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`&WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 {\xD4\xDFp\xC1\x8FM\xF4(@\xC4\x9B.\x80\x1F\xD9\x7F?\xFA\xFA6\x07\xA70i5U\xF9\xEA\"\x9BBdsolcC\0\x08\x1C\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212207bd4df70c18f4df42840c49b2e801fd97f3ffafa3607a730693555f9ea229b4264736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 {\xD4\xDFp\xC1\x8FM\xF4(@\xC4\x9B.\x80\x1F\xD9\x7F?\xFA\xFA6\x07\xA70i5U\xF9\xEA\"\x9BBdsolcC\0\x08\x1C\x003", + ); + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`StdConstants`](self) contract instance. + +See the [wrapper's documentation](`StdConstantsInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> StdConstantsInstance { + StdConstantsInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + StdConstantsInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + StdConstantsInstance::::deploy_builder(provider) + } + /**A [`StdConstants`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`StdConstants`](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 StdConstantsInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for StdConstantsInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("StdConstantsInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdConstantsInstance { + /**Creates a new wrapper around an on-chain [`StdConstants`](self) contract instance. + +See the [wrapper's documentation](`StdConstantsInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 StdConstantsInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> StdConstantsInstance { + StdConstantsInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdConstantsInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StdConstantsInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/strings.rs b/crates/bindings/src/strings.rs new file mode 100644 index 000000000..54f105906 --- /dev/null +++ b/crates/bindings/src/strings.rs @@ -0,0 +1,215 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface Strings {} +``` + +...which was generated by the following JSON ABI: +```json +[] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod Strings { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212201a58bdbfa53ac597b4722b5f67b03f2713f6c1425269a67f09d3aad6574b4bea64736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`U`2`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`&WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \x1AX\xBD\xBF\xA5:\xC5\x97\xB4r+_g\xB0?'\x13\xF6\xC1BRi\xA6\x7F\t\xD3\xAA\xD6WKK\xEAdsolcC\0\x08\x1C\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212201a58bdbfa53ac597b4722b5f67b03f2713f6c1425269a67f09d3aad6574b4bea64736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \x1AX\xBD\xBF\xA5:\xC5\x97\xB4r+_g\xB0?'\x13\xF6\xC1BRi\xA6\x7F\t\xD3\xAA\xD6WKK\xEAdsolcC\0\x08\x1C\x003", + ); + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`Strings`](self) contract instance. + +See the [wrapper's documentation](`StringsInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >(address: alloy_sol_types::private::Address, provider: P) -> StringsInstance { + StringsInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + StringsInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + StringsInstance::::deploy_builder(provider) + } + /**A [`Strings`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`Strings`](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 StringsInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for StringsInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("StringsInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StringsInstance { + /**Creates a new wrapper around an on-chain [`Strings`](self) contract instance. + +See the [wrapper's documentation](`StringsInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 StringsInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> StringsInstance { + StringsInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StringsInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > StringsInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/utilities.rs b/crates/bindings/src/utilities.rs new file mode 100644 index 000000000..cd31959cf --- /dev/null +++ b/crates/bindings/src/utilities.rs @@ -0,0 +1,3808 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface Utilities { + event log(string); + event log_address(address); + event log_bytes(bytes); + event log_bytes32(bytes32); + event log_int(int256); + event log_named_address(string key, address val); + event log_named_bytes(string key, bytes val); + event log_named_bytes32(string key, bytes32 val); + event log_named_decimal_int(string key, int256 val, uint256 decimals); + event log_named_decimal_uint(string key, uint256 val, uint256 decimals); + event log_named_int(string key, int256 val); + event log_named_string(string key, string val); + event log_named_uint(string key, uint256 val); + event log_string(string); + event log_uint(uint256); + event logs(bytes); + + function IS_TEST() external view returns (bool); + function createUsers(uint256 userNum) external returns (address payable[] memory); + function failed() external returns (bool); + function getNextUserAddress() external returns (address payable); + function mineBlocks(uint256 numBlocks) external; +} +``` + +...which was generated by the following JSON ABI: +```json +[ + { + "type": "function", + "name": "IS_TEST", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "createUsers", + "inputs": [ + { + "name": "userNum", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "address[]", + "internalType": "address payable[]" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "failed", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "getNextUserAddress", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address payable" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "mineBlocks", + "inputs": [ + { + "name": "numBlocks", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "event", + "name": "log", + "inputs": [ + { + "name": "", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_address", + "inputs": [ + { + "name": "", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_bytes", + "inputs": [ + { + "name": "", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_bytes32", + "inputs": [ + { + "name": "", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_int", + "inputs": [ + { + "name": "", + "type": "int256", + "indexed": false, + "internalType": "int256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_address", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_bytes", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "bytes", + "indexed": false, + "internalType": "bytes" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_bytes32", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "bytes32", + "indexed": false, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_decimal_int", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256", + "indexed": false, + "internalType": "int256" + }, + { + "name": "decimals", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_decimal_uint", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "decimals", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_int", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "int256", + "indexed": false, + "internalType": "int256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_string", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_named_uint", + "inputs": [ + { + "name": "key", + "type": "string", + "indexed": false, + "internalType": "string" + }, + { + "name": "val", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_string", + "inputs": [ + { + "name": "", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "log_uint", + "inputs": [ + { + "name": "", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "logs", + "inputs": [ + { + "name": "", + "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 Utilities { + use super::*; + use alloy::sol_types as 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"_\x80T`\xFF\x19\x16`\x01\x90\x81\x17\x90\x91Usq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x80Rkuser address`\xA0\x1B`\xC0R`\x0C`\xA0R`\xCC`@R\x7F\xFA\xDDiS\xA0Cn\x85R\x8D\xEDx\x9A\xF2\xE2\xB7\xE5|\x1C\xD7\xC6\x8C\\7\x96\xD8\xEAg\xE0\x01\x8D\xB7\x90U4\x80\x15`pW__\xFD[P`\x80Qa\x06\xC5a\0\x90_9_\x81\x81a\x02,\x01Ra\x04b\x01Ra\x06\xC5_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0dW_5`\xE0\x1C\x80c\xBAAO\xA6\x11a\0MW\x80c\xBAAO\xA6\x14a\0\xDBW\x80c\xF8-\xE7\xB0\x14a\0\xF3W\x80c\xFAv&\xD4\x14a\x01\x08W__\xFD[\x80cy.\x11\xF5\x14a\0hW\x80c\xB9\nh\xFA\x14a\0\x91W[__\xFD[a\0{a\0v6`\x04a\x04\xD2V[a\x01\x14V[`@Qa\0\x88\x91\x90a\x04\xE9V[`@Q\x80\x91\x03\x90\xF3[`\x01\x80T`@\x80Q` \x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x82\x01\x81R\x82\x84\x01\x93\x84\x90R\x80Q\x91\x01 \x90\x93Us\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x90R``\x01a\0\x88V[a\0\xE3a\x02\xCDV[`@Q\x90\x15\x15\x81R` \x01a\0\x88V[a\x01\x06a\x01\x016`\x04a\x04\xD2V[a\x04%V[\0[_Ta\0\xE3\x90`\xFF\x16\x81V[``_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x010Wa\x010a\x05AV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x01YW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x83\x81\x10\x15a\x02\xC6W_0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xB9\nh\xFA`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\xB1W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xD5\x91\x90a\x05nV[`@Q\x7F\xC8\x8A^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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x83\x16`\x04\x83\x01Rh\x05k\xC7^-c\x10\0\0`$\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\xC8\x8A^m\x90`D\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02oW__\xFD[PZ\xF1\x15\x80\x15a\x02\x81W=__>=_\xFD[PPPP\x80\x83\x83\x81Q\x81\x10a\x02\x98Wa\x02\x98a\x05\xA8V[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\x90\x91\x01RP`\x01\x01a\x01^V[P\x92\x91PPV[_\x80Ta\x01\0\x90\x04`\xFF\x16\x15a\x02\xEBWP_Ta\x01\0\x90\x04`\xFF\x16\x90V[_sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-;\x15a\x04 W`@\x80Qsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-` \x82\x01\x81\x90R\x7Ffailed\0\0\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\x82Q\x80\x83\x03\x84\x01\x81R``\x83\x01\x90\x93R_\x92\x90\x91a\x03\x8E\x91\x7Ff\x7F\x9Dp\xCAA\x1Dp\xEA\xD5\r\x8D\\\"\x07\r\xAF\xC3j\xD7_=\xCF^r7\xB2*\xDE\x9A\xEC\xC4\x91`\x80\x01a\x05\xECV[`@\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\x03\xC6\x91a\x06'V[_`@Q\x80\x83\x03\x81_\x86Z\xF1\x91PP=\x80_\x81\x14a\x03\xFFW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x04\x04V[``\x91P[P\x91PP\x80\x80` \x01\x90Q\x81\x01\x90a\x04\x1C\x91\x90a\x062V[\x91PP[\x91\x90PV[_a\x040\x82Ca\x06QV[`@Q\x7F\x1F{O0\0\0\0\0\0\0\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\x90\x91P\x7F\0\0\0\0\0\0\0\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\x1F{O0\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xB8W__\xFD[PZ\xF1\x15\x80\x15a\x04\xCAW=__>=_\xFD[PPPPPPV[_` \x82\x84\x03\x12\x15a\x04\xE2W__\xFD[P5\x91\x90PV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x056W\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\x05\x02V[P\x90\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x05~W__\xFD[\x81Qs\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\xA1W__\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[\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\x83\x16\x81R_a\x06\x1F`\x04\x83\x01\x84a\x05\xD5V[\x94\x93PPPPV[_a\x05\xA1\x82\x84a\x05\xD5V[_` \x82\x84\x03\x12\x15a\x06BW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x05\xA1W__\xFD[\x80\x82\x01\x80\x82\x11\x15a\x06\x89W\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\xA2dipfsX\"\x12 =\x07\xDC\x81\xE0Oz\xBB\x85\x1BO`p\xD3\xDA\xBFx\xFB\x08\xE9 1\x1D\xBA\xA4\xE1i\x83\x0B\x05\xDB\xE0dsolcC\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\0dW_5`\xE0\x1C\x80c\xBAAO\xA6\x11a\0MW\x80c\xBAAO\xA6\x14a\0\xDBW\x80c\xF8-\xE7\xB0\x14a\0\xF3W\x80c\xFAv&\xD4\x14a\x01\x08W__\xFD[\x80cy.\x11\xF5\x14a\0hW\x80c\xB9\nh\xFA\x14a\0\x91W[__\xFD[a\0{a\0v6`\x04a\x04\xD2V[a\x01\x14V[`@Qa\0\x88\x91\x90a\x04\xE9V[`@Q\x80\x91\x03\x90\xF3[`\x01\x80T`@\x80Q` \x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x82\x01\x81R\x82\x84\x01\x93\x84\x90R\x80Q\x91\x01 \x90\x93Us\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x90R``\x01a\0\x88V[a\0\xE3a\x02\xCDV[`@Q\x90\x15\x15\x81R` \x01a\0\x88V[a\x01\x06a\x01\x016`\x04a\x04\xD2V[a\x04%V[\0[_Ta\0\xE3\x90`\xFF\x16\x81V[``_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x010Wa\x010a\x05AV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x01YW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x83\x81\x10\x15a\x02\xC6W_0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xB9\nh\xFA`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\xB1W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xD5\x91\x90a\x05nV[`@Q\x7F\xC8\x8A^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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x83\x16`\x04\x83\x01Rh\x05k\xC7^-c\x10\0\0`$\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\xC8\x8A^m\x90`D\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02oW__\xFD[PZ\xF1\x15\x80\x15a\x02\x81W=__>=_\xFD[PPPP\x80\x83\x83\x81Q\x81\x10a\x02\x98Wa\x02\x98a\x05\xA8V[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\x90\x91\x01RP`\x01\x01a\x01^V[P\x92\x91PPV[_\x80Ta\x01\0\x90\x04`\xFF\x16\x15a\x02\xEBWP_Ta\x01\0\x90\x04`\xFF\x16\x90V[_sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-;\x15a\x04 W`@\x80Qsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-` \x82\x01\x81\x90R\x7Ffailed\0\0\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\x82Q\x80\x83\x03\x84\x01\x81R``\x83\x01\x90\x93R_\x92\x90\x91a\x03\x8E\x91\x7Ff\x7F\x9Dp\xCAA\x1Dp\xEA\xD5\r\x8D\\\"\x07\r\xAF\xC3j\xD7_=\xCF^r7\xB2*\xDE\x9A\xEC\xC4\x91`\x80\x01a\x05\xECV[`@\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\x03\xC6\x91a\x06'V[_`@Q\x80\x83\x03\x81_\x86Z\xF1\x91PP=\x80_\x81\x14a\x03\xFFW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x04\x04V[``\x91P[P\x91PP\x80\x80` \x01\x90Q\x81\x01\x90a\x04\x1C\x91\x90a\x062V[\x91PP[\x91\x90PV[_a\x040\x82Ca\x06QV[`@Q\x7F\x1F{O0\0\0\0\0\0\0\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\x90\x91P\x7F\0\0\0\0\0\0\0\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\x1F{O0\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xB8W__\xFD[PZ\xF1\x15\x80\x15a\x04\xCAW=__>=_\xFD[PPPPPPV[_` \x82\x84\x03\x12\x15a\x04\xE2W__\xFD[P5\x91\x90PV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x056W\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\x05\x02V[P\x90\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x05~W__\xFD[\x81Qs\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\xA1W__\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[\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\x83\x16\x81R_a\x06\x1F`\x04\x83\x01\x84a\x05\xD5V[\x94\x93PPPPV[_a\x05\xA1\x82\x84a\x05\xD5V[_` \x82\x84\x03\x12\x15a\x06BW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x05\xA1W__\xFD[\x80\x82\x01\x80\x82\x11\x15a\x06\x89W\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\xA2dipfsX\"\x12 =\x07\xDC\x81\xE0Oz\xBB\x85\x1BO`p\xD3\xDA\xBFx\xFB\x08\xE9 1\x1D\xBA\xA4\xE1i\x83\x0B\x05\xDB\xE0dsolcC\0\x08\x1C\x003", + ); + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. +```solidity +event log(string); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log { + type DataTuple<'a> = (alloy::sol_types::sol_data::String,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log(string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, + 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, + 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. +```solidity +event log_address(address); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_address { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_address { + type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_address(address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, + 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, + 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_address { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_address> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_address) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. +```solidity +event log_bytes(bytes); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_bytes { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_bytes { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_bytes(bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, + 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, + 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_bytes { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_bytes> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. +```solidity +event log_bytes32(bytes32); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_bytes32 { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_bytes32 { + type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_bytes32(bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, + 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, + 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_bytes32 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_bytes32> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. +```solidity +event log_int(int256); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_int { + #[allow(missing_docs)] + pub _0: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_int { + type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_int(int256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, + 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, + 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. +```solidity +event log_named_address(string key, address val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_address { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Address, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_address { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Address, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_address(string,address)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, + 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, + 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_address { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_address> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. +```solidity +event log_named_bytes(string key, bytes val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_bytes { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::Bytes, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_bytes { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Bytes, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, + 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, + 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_bytes { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_bytes> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. +```solidity +event log_named_bytes32(string key, bytes32 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_bytes32 { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_bytes32 { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::FixedBytes<32>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, + 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, + 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_bytes32 { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. +```solidity +event log_named_decimal_int(string key, int256 val, uint256 decimals); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_decimal_int { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::I256, + #[allow(missing_docs)] + pub decimals: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_decimal_int { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Int<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, + 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, + 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + key: data.0, + val: data.1, + decimals: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + as alloy_sol_types::SolType>::tokenize(&self.decimals), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_decimal_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. +```solidity +event log_named_decimal_uint(string key, uint256 val, uint256 decimals); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_decimal_uint { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::U256, + #[allow(missing_docs)] + pub decimals: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_decimal_uint { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Uint<256>, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, + 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, + 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { + key: data.0, + val: data.1, + decimals: data.2, + } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + as alloy_sol_types::SolType>::tokenize(&self.decimals), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. +```solidity +event log_named_int(string key, int256 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_int { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: 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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_int { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Int<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_int(string,int256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, + 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, + 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_int { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_int> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. +```solidity +event log_named_string(string key, string val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_string { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::String, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_string { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::String, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_string(string,string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, + 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, + 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + ::tokenize( + &self.val, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_string { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_string> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. +```solidity +event log_named_uint(string key, uint256 val); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_named_uint { + #[allow(missing_docs)] + pub key: alloy::sol_types::private::String, + #[allow(missing_docs)] + pub val: alloy::sol_types::private::primitives::aliases::U256, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_named_uint { + type DataTuple<'a> = ( + alloy::sol_types::sol_data::String, + alloy::sol_types::sol_data::Uint<256>, + ); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, + 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, + 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { key: data.0, val: data.1 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self.key, + ), + as alloy_sol_types::SolType>::tokenize(&self.val), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_named_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_named_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. +```solidity +event log_string(string); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_string { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_string { + type DataTuple<'a> = (alloy::sol_types::sol_data::String,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_string(string)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, + 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, + 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_string { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_string> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_string) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. +```solidity +event log_uint(uint256); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct log_uint { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for log_uint { + type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "log_uint(uint256)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, + 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, + 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self._0), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 log_uint { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&log_uint> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &log_uint) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. +```solidity +event logs(bytes); +```*/ + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + #[derive(Clone)] + pub struct logs { + #[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 as alloy_sol_types; + #[automatically_derived] + impl alloy_sol_types::SolEvent for logs { + type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); + const SIGNATURE: &'static str = "logs(bytes)"; + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, + 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, + 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, + ]); + const ANONYMOUS: bool = false; + #[allow(unused_variables)] + #[inline] + fn new( + topics: ::RustType, + data: as alloy_sol_types::SolType>::RustType, + ) -> Self { + Self { _0: data.0 } + } + #[inline] + fn check_signature( + topics: &::RustType, + ) -> alloy_sol_types::Result<()> { + if topics.0 != Self::SIGNATURE_HASH { + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); + } + Ok(()) + } + #[inline] + fn tokenize_body(&self) -> Self::DataToken<'_> { + ( + ::tokenize( + &self._0, + ), + ) + } + #[inline] + fn topics(&self) -> ::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() < ::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 logs { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + From::from(self) + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + From::from(&self) + } + } + #[automatically_derived] + impl From<&logs> for alloy_sol_types::private::LogData { + #[inline] + fn from(this: &logs) -> alloy_sol_types::private::LogData { + alloy_sol_types::SolEvent::encode_log_data(this) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. +```solidity +function IS_TEST() external view returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IS_TESTCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct IS_TESTReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IS_TESTCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IS_TESTCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: IS_TESTReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for IS_TESTReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for IS_TESTCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "IS_TEST()"; + const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: IS_TESTReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: IS_TESTReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `createUsers(uint256)` and selector `0x792e11f5`. +```solidity +function createUsers(uint256 userNum) external returns (address[] memory); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct createUsersCall { + #[allow(missing_docs)] + pub userNum: alloy::sol_types::private::primitives::aliases::U256, + } + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`createUsers(uint256)`](createUsersCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct createUsersReturn { + #[allow(missing_docs)] + pub _0: alloy::sol_types::private::Vec, + } + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: createUsersCall) -> Self { + (value.userNum,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for createUsersCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { userNum: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::Vec, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: createUsersReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for createUsersReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for createUsersCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Vec< + alloy::sol_types::private::Address, + >; + type ReturnTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "createUsers(uint256)"; + const SELECTOR: [u8; 4] = [121u8, 46u8, 17u8, 245u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.userNum), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + as alloy_sol_types::SolType>::tokenize(ret), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: createUsersReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: createUsersReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `failed()` and selector `0xba414fa6`. +```solidity +function failed() external returns (bool); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct failedCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`failed()`](failedCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct failedReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: failedCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for failedCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + 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, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: failedReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for failedReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for failedCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = bool; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "failed()"; + const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: failedReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: failedReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `getNextUserAddress()` and selector `0xb90a68fa`. +```solidity +function getNextUserAddress() external returns (address); +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getNextUserAddressCall; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + ///Container type for the return parameters of the [`getNextUserAddress()`](getNextUserAddressCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct getNextUserAddressReturn { + #[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 as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getNextUserAddressCall) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getNextUserAddressCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From + for UnderlyingRustTuple<'_> { + fn from(value: getNextUserAddressReturn) -> Self { + (value._0,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> + for getNextUserAddressReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { _0: tuple.0 } + } + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for getNextUserAddressCall { + type Parameters<'a> = (); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = alloy::sol_types::private::Address; + type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "getNextUserAddress()"; + const SELECTOR: [u8; 4] = [185u8, 10u8, 104u8, 250u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + () + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + ( + ::tokenize( + ret, + ), + ) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(|r| { + let r: getNextUserAddressReturn = r.into(); + r._0 + }) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(|r| { + let r: getNextUserAddressReturn = r.into(); + r._0 + }) + } + } + }; + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Default, Debug, PartialEq, Eq, Hash)] + /**Function with signature `mineBlocks(uint256)` and selector `0xf82de7b0`. +```solidity +function mineBlocks(uint256 numBlocks) external; +```*/ + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct mineBlocksCall { + #[allow(missing_docs)] + pub numBlocks: alloy::sol_types::private::primitives::aliases::U256, + } + ///Container type for the return parameters of the [`mineBlocks(uint256)`](mineBlocksCall) function. + #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] + #[derive(Clone)] + pub struct mineBlocksReturn {} + #[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style + )] + const _: () = { + use alloy::sol_types as alloy_sol_types; + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: mineBlocksCall) -> Self { + (value.numBlocks,) + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for mineBlocksCall { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self { numBlocks: tuple.0 } + } + } + } + { + #[doc(hidden)] + type UnderlyingSolTuple<'a> = (); + #[doc(hidden)] + type UnderlyingRustTuple<'a> = (); + #[cfg(test)] + #[allow(dead_code, unreachable_patterns)] + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { + match _t { + alloy_sol_types::private::AssertTypeEq::< + ::RustType, + >(_) => {} + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From for UnderlyingRustTuple<'_> { + fn from(value: mineBlocksReturn) -> Self { + () + } + } + #[automatically_derived] + #[doc(hidden)] + impl ::core::convert::From> for mineBlocksReturn { + fn from(tuple: UnderlyingRustTuple<'_>) -> Self { + Self {} + } + } + } + impl mineBlocksReturn { + fn _tokenize( + &self, + ) -> ::ReturnToken<'_> { + () + } + } + #[automatically_derived] + impl alloy_sol_types::SolCall for mineBlocksCall { + type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = mineBlocksReturn; + type ReturnTuple<'a> = (); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "mineBlocks(uint256)"; + const SELECTOR: [u8; 4] = [248u8, 45u8, 231u8, 176u8]; + #[inline] + fn new<'a>( + tuple: as alloy_sol_types::SolType>::RustType, + ) -> Self { + tuple.into() + } + #[inline] + fn tokenize(&self) -> Self::Token<'_> { + ( + as alloy_sol_types::SolType>::tokenize(&self.numBlocks), + ) + } + #[inline] + fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { + mineBlocksReturn::_tokenize(ret) + } + #[inline] + fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence(data) + .map(Into::into) + } + #[inline] + fn abi_decode_returns_validate( + data: &[u8], + ) -> alloy_sol_types::Result { + as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) + .map(Into::into) + } + } + }; + ///Container for all the [`Utilities`](self) function calls. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive()] + pub enum UtilitiesCalls { + #[allow(missing_docs)] + IS_TEST(IS_TESTCall), + #[allow(missing_docs)] + createUsers(createUsersCall), + #[allow(missing_docs)] + failed(failedCall), + #[allow(missing_docs)] + getNextUserAddress(getNextUserAddressCall), + #[allow(missing_docs)] + mineBlocks(mineBlocksCall), + } + #[automatically_derived] + impl UtilitiesCalls { + /// 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, 46u8, 17u8, 245u8], + [185u8, 10u8, 104u8, 250u8], + [186u8, 65u8, 79u8, 166u8], + [248u8, 45u8, 231u8, 176u8], + [250u8, 118u8, 38u8, 212u8], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolInterface for UtilitiesCalls { + const NAME: &'static str = "UtilitiesCalls"; + const MIN_DATA_LENGTH: usize = 0usize; + const COUNT: usize = 5usize; + #[inline] + fn selector(&self) -> [u8; 4] { + match self { + Self::IS_TEST(_) => ::SELECTOR, + Self::createUsers(_) => { + ::SELECTOR + } + Self::failed(_) => ::SELECTOR, + Self::getNextUserAddress(_) => { + ::SELECTOR + } + Self::mineBlocks(_) => { + ::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 { + static DECODE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn createUsers( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(UtilitiesCalls::createUsers) + } + createUsers + }, + { + fn getNextUserAddress( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(UtilitiesCalls::getNextUserAddress) + } + getNextUserAddress + }, + { + fn failed(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(UtilitiesCalls::failed) + } + failed + }, + { + fn mineBlocks( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + ) + .map(UtilitiesCalls::mineBlocks) + } + mineBlocks + }, + { + fn IS_TEST(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw(data) + .map(UtilitiesCalls::IS_TEST) + } + IS_TEST + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::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 { + static DECODE_VALIDATE_SHIMS: &[fn( + &[u8], + ) -> alloy_sol_types::Result] = &[ + { + fn createUsers( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(UtilitiesCalls::createUsers) + } + createUsers + }, + { + fn getNextUserAddress( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(UtilitiesCalls::getNextUserAddress) + } + getNextUserAddress + }, + { + fn failed(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(UtilitiesCalls::failed) + } + failed + }, + { + fn mineBlocks( + data: &[u8], + ) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(UtilitiesCalls::mineBlocks) + } + mineBlocks + }, + { + fn IS_TEST(data: &[u8]) -> alloy_sol_types::Result { + ::abi_decode_raw_validate( + data, + ) + .map(UtilitiesCalls::IS_TEST) + } + IS_TEST + }, + ]; + let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); + }; + DECODE_VALIDATE_SHIMS[idx](data) + } + #[inline] + fn abi_encoded_size(&self) -> usize { + match self { + Self::IS_TEST(inner) => { + ::abi_encoded_size(inner) + } + Self::createUsers(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::failed(inner) => { + ::abi_encoded_size(inner) + } + Self::getNextUserAddress(inner) => { + ::abi_encoded_size( + inner, + ) + } + Self::mineBlocks(inner) => { + ::abi_encoded_size(inner) + } + } + } + #[inline] + fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { + match self { + Self::IS_TEST(inner) => { + ::abi_encode_raw(inner, out) + } + Self::createUsers(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::failed(inner) => { + ::abi_encode_raw(inner, out) + } + Self::getNextUserAddress(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + Self::mineBlocks(inner) => { + ::abi_encode_raw( + inner, + out, + ) + } + } + } + } + ///Container for all the [`Utilities`](self) events. + #[derive(serde::Serialize, serde::Deserialize)] + #[derive(Debug, PartialEq, Eq, Hash)] + pub enum UtilitiesEvents { + #[allow(missing_docs)] + log(log), + #[allow(missing_docs)] + log_address(log_address), + #[allow(missing_docs)] + log_bytes(log_bytes), + #[allow(missing_docs)] + log_bytes32(log_bytes32), + #[allow(missing_docs)] + log_int(log_int), + #[allow(missing_docs)] + log_named_address(log_named_address), + #[allow(missing_docs)] + log_named_bytes(log_named_bytes), + #[allow(missing_docs)] + log_named_bytes32(log_named_bytes32), + #[allow(missing_docs)] + log_named_decimal_int(log_named_decimal_int), + #[allow(missing_docs)] + log_named_decimal_uint(log_named_decimal_uint), + #[allow(missing_docs)] + log_named_int(log_named_int), + #[allow(missing_docs)] + log_named_string(log_named_string), + #[allow(missing_docs)] + log_named_uint(log_named_uint), + #[allow(missing_docs)] + log_string(log_string), + #[allow(missing_docs)] + log_uint(log_uint), + #[allow(missing_docs)] + logs(logs), + } + #[automatically_derived] + impl UtilitiesEvents { + /// 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]] = &[ + [ + 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, + 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, + 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, + ], + [ + 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, + 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, + 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, + ], + [ + 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, + 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, + 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, + ], + [ + 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, + 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, + 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, + ], + [ + 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, + 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, + 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, + ], + [ + 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, + 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, + 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, + ], + [ + 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, + 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, + 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, + ], + [ + 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, + 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, + 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, + ], + [ + 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, + 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, + 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, + ], + [ + 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, + 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, + 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, + ], + [ + 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, + 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, + 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, + ], + [ + 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, + 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, + 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, + ], + [ + 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, + 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, + 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, + ], + [ + 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, + 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, + 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, + ], + [ + 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, + 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, + 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, + ], + [ + 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, + 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, + 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, + ], + ]; + } + #[automatically_derived] + impl alloy_sol_types::SolEventInterface for UtilitiesEvents { + const NAME: &'static str = "UtilitiesEvents"; + const COUNT: usize = 16usize; + fn decode_raw_log( + topics: &[alloy_sol_types::Word], + data: &[u8], + ) -> alloy_sol_types::Result { + match topics.first().copied() { + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_address) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_bytes) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_bytes32) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log_int) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_address) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_bytes) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_bytes32) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_decimal_int) + } + Some( + ::SIGNATURE_HASH, + ) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_decimal_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_int) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_string) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_named_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log( + topics, + data, + ) + .map(Self::log_string) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::log_uint) + } + Some(::SIGNATURE_HASH) => { + ::decode_raw_log(topics, data) + .map(Self::logs) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::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 UtilitiesEvents { + fn to_log_data(&self) -> alloy_sol_types::private::LogData { + match self { + Self::log(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_address(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_bytes(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_address(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_bytes(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_decimal_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_decimal_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_int(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_string(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_named_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_string(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::log_uint(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::logs(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + } + } + fn into_log_data(self) -> alloy_sol_types::private::LogData { + match self { + Self::log(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_address(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_bytes(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_address(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_bytes(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_bytes32(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_decimal_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_decimal_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_int(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_string(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_named_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_string(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::log_uint(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + Self::logs(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } + } + } + } + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`Utilities`](self) contract instance. + +See the [wrapper's documentation](`UtilitiesInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> UtilitiesInstance { + UtilitiesInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + UtilitiesInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + UtilitiesInstance::::deploy_builder(provider) + } + /**A [`Utilities`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`Utilities`](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 UtilitiesInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for UtilitiesInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("UtilitiesInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > UtilitiesInstance { + /**Creates a new wrapper around an on-chain [`Utilities`](self) contract instance. + +See the [wrapper's documentation](`UtilitiesInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 UtilitiesInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> UtilitiesInstance { + UtilitiesInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > UtilitiesInstance { + /// 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( + &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 [`IS_TEST`] function. + pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { + self.call_builder(&IS_TESTCall) + } + ///Creates a new call builder for the [`createUsers`] function. + pub fn createUsers( + &self, + userNum: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, createUsersCall, N> { + self.call_builder(&createUsersCall { userNum }) + } + ///Creates a new call builder for the [`failed`] function. + pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { + self.call_builder(&failedCall) + } + ///Creates a new call builder for the [`getNextUserAddress`] function. + pub fn getNextUserAddress( + &self, + ) -> alloy_contract::SolCallBuilder<&P, getNextUserAddressCall, N> { + self.call_builder(&getNextUserAddressCall) + } + ///Creates a new call builder for the [`mineBlocks`] function. + pub fn mineBlocks( + &self, + numBlocks: alloy::sol_types::private::primitives::aliases::U256, + ) -> alloy_contract::SolCallBuilder<&P, mineBlocksCall, N> { + self.call_builder(&mineBlocksCall { numBlocks }) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > UtilitiesInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + ///Creates a new event filter for the [`log`] event. + pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_address`] event. + pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_bytes`] event. + pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_bytes32`] event. + pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_int`] event. + pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_address`] event. + pub fn log_named_address_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_address, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_bytes`] event. + pub fn log_named_bytes_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_bytes, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_bytes32`] event. + pub fn log_named_bytes32_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_bytes32, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_decimal_int`] event. + pub fn log_named_decimal_int_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_decimal_uint`] event. + pub fn log_named_decimal_uint_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_int`] event. + pub fn log_named_int_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_int, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_string`] event. + pub fn log_named_string_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_string, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_named_uint`] event. + pub fn log_named_uint_filter( + &self, + ) -> alloy_contract::Event<&P, log_named_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_string`] event. + pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`log_uint`] event. + pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { + self.event_filter::() + } + ///Creates a new event filter for the [`logs`] event. + pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { + self.event_filter::() + } + } +} diff --git a/crates/bindings/src/validate_spv.rs b/crates/bindings/src/validate_spv.rs new file mode 100644 index 000000000..fa396186b --- /dev/null +++ b/crates/bindings/src/validate_spv.rs @@ -0,0 +1,218 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface ValidateSPV {} +``` + +...which was generated by the following JSON ABI: +```json +[] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod ValidateSPV { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220ee27a3db5def4161da3b0372a7dfce300ba5ffcd5c6cb8bb7aefea14f26619bb64736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`U`2`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`&WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \xEE'\xA3\xDB]\xEFAa\xDA;\x03r\xA7\xDF\xCE0\x0B\xA5\xFF\xCD\\l\xB8\xBBz\xEF\xEA\x14\xF2f\x19\xBBdsolcC\0\x08\x1C\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220ee27a3db5def4161da3b0372a7dfce300ba5ffcd5c6cb8bb7aefea14f26619bb64736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \xEE'\xA3\xDB]\xEFAa\xDA;\x03r\xA7\xDF\xCE0\x0B\xA5\xFF\xCD\\l\xB8\xBBz\xEF\xEA\x14\xF2f\x19\xBBdsolcC\0\x08\x1C\x003", + ); + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`ValidateSPV`](self) contract instance. + +See the [wrapper's documentation](`ValidateSPVInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> ValidateSPVInstance { + ValidateSPVInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + ValidateSPVInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + ValidateSPVInstance::::deploy_builder(provider) + } + /**A [`ValidateSPV`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`ValidateSPV`](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 ValidateSPVInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for ValidateSPVInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("ValidateSPVInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ValidateSPVInstance { + /**Creates a new wrapper around an on-chain [`ValidateSPV`](self) contract instance. + +See the [wrapper's documentation](`ValidateSPVInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 ValidateSPVInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> ValidateSPVInstance { + ValidateSPVInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ValidateSPVInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ValidateSPVInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/crates/bindings/src/witness_tx.rs b/crates/bindings/src/witness_tx.rs new file mode 100644 index 000000000..f93a810ef --- /dev/null +++ b/crates/bindings/src/witness_tx.rs @@ -0,0 +1,218 @@ +/** + +Generated by the following Solidity interface... +```solidity +interface WitnessTx {} +``` + +...which was generated by the following JSON ABI: +```json +[] +```*/ +#[allow( + non_camel_case_types, + non_snake_case, + clippy::pub_underscore_fields, + clippy::style, + clippy::empty_structs_with_brackets +)] +pub mod WitnessTx { + use super::*; + use alloy::sol_types as alloy_sol_types; + /// The creation / init bytecode of the contract. + /// + /// ```text + ///0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212203dc01a9a718437076a07a4276ef476fe65a24b003d001d99855a279245af3ec464736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"`U`2`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`&WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 =\xC0\x1A\x9Aq\x847\x07j\x07\xA4'n\xF4v\xFEe\xA2K\0=\0\x1D\x99\x85Z'\x92E\xAF>\xC4dsolcC\0\x08\x1C\x003", + ); + /// The runtime bytecode of the contract, as deployed on the network. + /// + /// ```text + ///0x730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212203dc01a9a718437076a07a4276ef476fe65a24b003d001d99855a279245af3ec464736f6c634300081c0033 + /// ``` + #[rustfmt::skip] + #[allow(clippy::all)] + pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( + b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 =\xC0\x1A\x9Aq\x847\x07j\x07\xA4'n\xF4v\xFEe\xA2K\0=\0\x1D\x99\x85Z'\x92E\xAF>\xC4dsolcC\0\x08\x1C\x003", + ); + use alloy::contract as alloy_contract; + /**Creates a new wrapper around an on-chain [`WitnessTx`](self) contract instance. + +See the [wrapper's documentation](`WitnessTxInstance`) for more details.*/ + #[inline] + pub const fn new< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + >( + address: alloy_sol_types::private::Address, + provider: P, + ) -> WitnessTxInstance { + WitnessTxInstance::::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: alloy_contract::private::Network, + >( + provider: P, + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + WitnessTxInstance::::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: alloy_contract::private::Network, + >(provider: P) -> alloy_contract::RawCallBuilder { + WitnessTxInstance::::deploy_builder(provider) + } + /**A [`WitnessTx`](self) instance. + +Contains type-safe methods for interacting with an on-chain instance of the +[`WitnessTx`](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 WitnessTxInstance { + address: alloy_sol_types::private::Address, + provider: P, + _network: ::core::marker::PhantomData, + } + #[automatically_derived] + impl ::core::fmt::Debug for WitnessTxInstance { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { + f.debug_tuple("WitnessTxInstance").field(&self.address).finish() + } + } + /// Instantiation and getters/setters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > WitnessTxInstance { + /**Creates a new wrapper around an on-chain [`WitnessTx`](self) contract instance. + +See the [wrapper's documentation](`WitnessTxInstance`) for more details.*/ + #[inline] + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { + Self { + address, + 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> { + 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 { + 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 WitnessTxInstance<&P, N> { + /// Clones the provider and returns a new instance with the cloned provider. + #[inline] + pub fn with_cloned_provider(self) -> WitnessTxInstance { + WitnessTxInstance { + address: self.address, + provider: ::core::clone::Clone::clone(&self.provider), + _network: ::core::marker::PhantomData, + } + } + } + /// Function calls. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > WitnessTxInstance { + /// 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( + &self, + call: &C, + ) -> alloy_contract::SolCallBuilder<&P, C, N> { + alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) + } + } + /// Event filters. + #[automatically_derived] + impl< + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > WitnessTxInstance { + /// 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( + &self, + ) -> alloy_contract::Event<&P, E, N> { + alloy_contract::Event::new_sol(&self.provider, &self.address) + } + } +} diff --git a/relayer/src/relayer.rs b/relayer/src/relayer.rs index 9b1dd8c7a..4a2eb0073 100644 --- a/relayer/src/relayer.rs +++ b/relayer/src/relayer.rs @@ -12,7 +12,7 @@ use alloy::{ sol_types::SolCall, transports::RpcError, }; -use bindings::fullrelaywithverify::{ +use bindings::full_relay_with_verify::{ FullRelayWithVerify as BitcoinRelay, FullRelayWithVerify::FullRelayWithVerifyInstance as BitcoinRelayInstance, }; @@ -383,7 +383,7 @@ impl Relayer { let input = tx.as_ref().input(); - use bindings::fullrelaywithverify::FullRelayWithVerify::markNewHeaviestCall; + use bindings::full_relay_with_verify::FullRelayWithVerify::markNewHeaviestCall; let decoded = markNewHeaviestCall::abi_decode(input)?; let header: bitcoin::block::Header = bitcoin::consensus::deserialize(&decoded._newBest.0)?; From 1ae6b981beecb500a162d09337543cf1f286f286 Mon Sep 17 00:00:00 2001 From: nazeh Date: Thu, 12 Jun 2025 15:44:20 +0300 Subject: [PATCH 11/24] feat(relayer): reduce run interval for regtest --- relayer/src/relayer.rs | 49 ++++++++++++++++++++++++++++++++---------- 1 file changed, 38 insertions(+), 11 deletions(-) diff --git a/relayer/src/relayer.rs b/relayer/src/relayer.rs index 4a2eb0073..5a0431be8 100644 --- a/relayer/src/relayer.rs +++ b/relayer/src/relayer.rs @@ -57,6 +57,7 @@ impl RelayHeader { } } +#[derive(Clone)] pub struct Relayer { pub contract: BitcoinRelayInstance, pub esplora_client: EsploraClient, @@ -93,10 +94,19 @@ impl Relayer { ) -> Result
{ let provider = ProviderBuilder::new().wallet(wallet.clone()).connect_http(rpc_url.clone()); - let period_start_block_hash = esplora_client.get_block_hash(period_start_height).await?; - let genesis_block_header = esplora_client - .get_raw_block_header(&esplora_client.get_block_hash(genesis_height).await?) - .await?; + let period_start_block_hash = esplora_client + .get_block_hash(period_start_height) + .await + .map_err(|_| eyre!("Couldn't find block hash at period_start_height"))?; + let genesis_block_hash = esplora_client + .get_block_hash(genesis_height) + .await + .map_err(|_| eyre!("Couldn't find block hash at genesis_height"))?; + let genesis_block_header = + esplora_client + .get_raw_block_header(&genesis_block_hash) + .await + .map_err(|_| eyre!("Couldn't find block header at genesis_height"))?; let contract = BitcoinRelay::deploy( provider.clone(), @@ -170,7 +180,12 @@ impl Relayer { if headers.is_empty() { // we are up to date, sleep for a bit - tokio::time::sleep(Duration::from_secs(15)).await; + tokio::time::sleep(if self.is_regtest() { + Duration::from_millis(15) + } else { + Duration::from_secs(15) + }) + .await; } else { self.push_headers(headers).await?; } @@ -204,6 +219,10 @@ impl Relayer { } async fn push_headers(&self, headers: Vec) -> Result<()> { + if headers.is_empty() { + return Ok(()); + } + let start_mod = headers.first().unwrap().height % 2016; let end_header = headers.last().unwrap().clone(); let end_mod = end_header.height % 2016; @@ -309,11 +328,7 @@ impl Relayer { } async fn update_best_digest(&self, new_best: RelayHeader) -> Result<()> { - let current_best = if self.contract.provider().client().is_local() { - self.get_heaviest_relayed_block_header_regtest().await? - } else { - self.get_heaviest_relayed_block_header().await? - }; + let current_best = self.get_heaviest_relayed_block_header().await?; let ancestor = self.find_lca(&new_best, current_best.clone()).await?; let delta = new_best.height - ancestor.height + 1; @@ -335,13 +350,21 @@ impl Relayer { Ok(()) } + async fn get_heaviest_relayed_block_header(&self) -> Result { + if self.is_regtest() { + self.get_heaviest_relayed_block_header_regtest().await + } else { + self.get_heaviest_relayed_block_header_goldsky().await + } + } + /// Fetch the block header from the contract. We used to fetch from esplora but that would /// fail if there was a fork. This function is currently a bit over engineered - it uses /// a subgraph to find the tx that submitted the heaviest block, then takes the blockheader /// from its calldata. It would have been a lot easier if the smart contract were to store /// the blockheader directly - something we might do in the future. That would come at the /// cost of additional gas usage though. - async fn get_heaviest_relayed_block_header(&self) -> Result { + async fn get_heaviest_relayed_block_header_goldsky(&self) -> Result { let relayer_blockhash = self.contract.getBestKnownDigest().call().await?; let query = format!( @@ -408,6 +431,10 @@ impl Relayer { .expect("height larger than u32::MAX"), }) } + + fn is_regtest(&self) -> bool { + self.contract.provider().client().is_local() + } } #[cfg(test)] From 2c59391582322dd342fbefd9fdac0db057e0f361 Mon Sep 17 00:00:00 2001 From: nazeh Date: Thu, 12 Jun 2025 15:47:34 +0300 Subject: [PATCH 12/24] feat(relayer): add contract_address() getter --- relayer/src/relayer.rs | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/relayer/src/relayer.rs b/relayer/src/relayer.rs index 5a0431be8..ae2df92c8 100644 --- a/relayer/src/relayer.rs +++ b/relayer/src/relayer.rs @@ -59,8 +59,8 @@ impl RelayHeader { #[derive(Clone)] pub struct Relayer { - pub contract: BitcoinRelayInstance, - pub esplora_client: EsploraClient, + contract: BitcoinRelayInstance, + esplora_client: EsploraClient, } // https://github.com/summa-tx/relays/tree/master/maintainer/maintainer/header_forwarder @@ -119,6 +119,10 @@ impl Relayer { Ok(*contract.address()) } + pub fn contract_address(&self) -> Address { + *self.contract.address() + } + async fn relayed_height(&self) -> Result { let relayer_blockhash = self.contract.getBestKnownDigest().call().await?; let relayed_height: u32 = From 59c3a8aec0c0d3fec4cc9c90e65e2fae3362385a Mon Sep 17 00:00:00 2001 From: nazeh Date: Fri, 13 Jun 2025 09:59:28 +0300 Subject: [PATCH 13/24] feat(relayer): replace println! with tracing::debug --- relayer/Cargo.toml | 1 + relayer/src/relayer.rs | 13 +++++++------ 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/relayer/Cargo.toml b/relayer/Cargo.toml index 8a9bc28b1..8d93a559d 100644 --- a/relayer/Cargo.toml +++ b/relayer/Cargo.toml @@ -18,3 +18,4 @@ bitcoin = { workspace = true, features = ["serde"] } # Ethereum alloy = { workspace = true, features = ["full", "providers", "node-bindings"] } serde_json = "1.0.140" +tracing = "0.1.41" diff --git a/relayer/src/relayer.rs b/relayer/src/relayer.rs index ae2df92c8..408c01114 100644 --- a/relayer/src/relayer.rs +++ b/relayer/src/relayer.rs @@ -158,7 +158,7 @@ impl Relayer { return Ok(height); } - println!("Found fork: {actual_hash} at height {height}"); + tracing::debug!("Found fork: {actual_hash} at height {height}"); if height == 0 { return Err(eyre!("No common height found before reaching 0")); } @@ -201,7 +201,7 @@ impl Relayer { // let futures = (latest_height..latest_height + HEADERS_PER_BATCH as u32) // .map(|height| async move { - // println!("fetching height {}", height); + // tracing::debug!("fetching height {}", height); // let hash = self.esplora_client.get_block_hash(height).await?; // let header = self.esplora_client.get_block_header(&hash).await?; // Ok(RelayHeader { hash, header, height }) as Result @@ -215,6 +215,7 @@ impl Relayer { for height in latest_height..(latest_height + HEADERS_PER_BATCH as u32).min(bitcoin_height + 1) { + tracing::debug!("fetching height {}", height); let hash = self.esplora_client.get_block_hash(height).await?; let header = self.esplora_client.get_block_header(&hash).await?; relay_headers.push(RelayHeader { hash, header, height }); @@ -233,12 +234,12 @@ impl Relayer { // difficulty change first if start_mod == 0 { - println!("difficulty change first"); + tracing::debug!("difficulty change first"); self.add_diff_change(headers).await?; } // spanning difficulty change else if start_mod > end_mod { - println!("spanning difficulty change"); + tracing::debug!("spanning difficulty change"); let (pre_change, post_change): (Vec, Vec) = headers.into_iter().partition(|header| header.height % 2016 >= start_mod); @@ -252,11 +253,11 @@ impl Relayer { } // no difficulty change else { - println!("adding headers"); + tracing::debug!("adding headers"); self.add_headers(headers).await?; } - println!("updating head"); + tracing::debug!("updating head"); self.update_best_digest(end_header).await?; Ok(()) From 6973533c898aa358cce3aee0dbcc714f1ed5d241 Mon Sep 17 00:00:00 2001 From: nazeh Date: Fri, 13 Jun 2025 10:46:55 +0300 Subject: [PATCH 14/24] feat(relayer): make some getters public --- relayer/src/relayer.rs | 20 +++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/relayer/src/relayer.rs b/relayer/src/relayer.rs index 408c01114..616c4e456 100644 --- a/relayer/src/relayer.rs +++ b/relayer/src/relayer.rs @@ -123,7 +123,8 @@ impl Relayer { *self.contract.address() } - async fn relayed_height(&self) -> Result { + // Returns the height relayed to the smart contract so far. + pub async fn relayed_height(&self) -> Result { let relayer_blockhash = self.contract.getBestKnownDigest().call().await?; let relayed_height: u32 = self.contract.findHeight(relayer_blockhash).call().await?.try_into().unwrap(); @@ -131,7 +132,8 @@ impl Relayer { Ok(relayed_height) } - async fn has_relayed(&self, blockhash: BlockHash) -> Result { + // Returns true if the block with this hash was relayed to the contract. + pub async fn has_relayed(&self, blockhash: BlockHash) -> Result { let result = self.contract.findHeight(blockhash.to_byte_array().into()).call().await; match result { @@ -166,11 +168,14 @@ impl Relayer { } } - #[allow(unused)] pub async fn run_once(&self) -> Result<()> { let latest_height = self.latest_common_height().await?; let headers: Vec = self.pull_headers(latest_height).await?; - self.push_headers(headers).await?; + if !headers.is_empty() { + self.push_headers(headers).await?; + } else { + tracing::debug!("No headers to push..."); + } Ok(()) } @@ -183,9 +188,10 @@ impl Relayer { latest_height += headers.len() as u32; if headers.is_empty() { + tracing::debug!("No headers to push..."); // we are up to date, sleep for a bit tokio::time::sleep(if self.is_regtest() { - Duration::from_millis(15) + Duration::from_millis(150) } else { Duration::from_secs(15) }) @@ -224,10 +230,6 @@ impl Relayer { } async fn push_headers(&self, headers: Vec) -> Result<()> { - if headers.is_empty() { - return Ok(()); - } - let start_mod = headers.first().unwrap().height % 2016; let end_header = headers.last().unwrap().clone(); let end_mod = end_header.height % 2016; From b01be4dd439b9c2406357830ef29fe7f30758c56 Mon Sep 17 00:00:00 2001 From: nazeh Date: Sat, 14 Jun 2025 00:16:37 +0300 Subject: [PATCH 15/24] feat(relayer): add relayed_blockhash() and use larger HEADERS_PER_BATCH in regtest --- relayer/src/relayer.rs | 63 +++++++++++++++++++++++++++--------------- 1 file changed, 40 insertions(+), 23 deletions(-) diff --git a/relayer/src/relayer.rs b/relayer/src/relayer.rs index 616c4e456..a4f982fe5 100644 --- a/relayer/src/relayer.rs +++ b/relayer/src/relayer.rs @@ -23,7 +23,7 @@ use serde_json::Value; use std::time::Duration; use utils::EsploraClient; -const HEADERS_PER_BATCH: usize = 5; +const HEADERS_PER_BATCH: u32 = 5; type ContractProvider = FillProvider< JoinFill< @@ -123,7 +123,7 @@ impl Relayer { *self.contract.address() } - // Returns the height relayed to the smart contract so far. + /// Returns the height relayed to the smart contract so far. pub async fn relayed_height(&self) -> Result { let relayer_blockhash = self.contract.getBestKnownDigest().call().await?; let relayed_height: u32 = @@ -132,7 +132,17 @@ impl Relayer { Ok(relayed_height) } - // Returns true if the block with this hash was relayed to the contract. + /// Returns the block hash of the most recent relayed block. + pub async fn relayed_blockhash(&self) -> Result { + Ok(self + .contract + .getBestKnownDigest() + .call() + .await + .map(|bytes| BlockHash::from_byte_array(bytes.into()))?) + } + + /// Returns true if the block with this hash was relayed to the contract. pub async fn has_relayed(&self, blockhash: BlockHash) -> Result { let result = self.contract.findHeight(blockhash.to_byte_array().into()).call().await; @@ -171,11 +181,7 @@ impl Relayer { pub async fn run_once(&self) -> Result<()> { let latest_height = self.latest_common_height().await?; let headers: Vec = self.pull_headers(latest_height).await?; - if !headers.is_empty() { - self.push_headers(headers).await?; - } else { - tracing::debug!("No headers to push..."); - } + self.push_headers(headers).await?; Ok(()) } @@ -187,25 +193,25 @@ impl Relayer { latest_height += headers.len() as u32; - if headers.is_empty() { - tracing::debug!("No headers to push..."); - // we are up to date, sleep for a bit - tokio::time::sleep(if self.is_regtest() { - Duration::from_millis(150) - } else { - Duration::from_secs(15) - }) - .await; + self.push_headers(headers).await?; + + tokio::time::sleep(if self.is_regtest() { + Duration::from_millis(10) } else { - self.push_headers(headers).await?; - } + Duration::from_secs(15) + }) + .await; } } async fn pull_headers(&self, mut latest_height: u32) -> Result> { latest_height += 1; - // let futures = (latest_height..latest_height + HEADERS_PER_BATCH as u32) + // Larger batches are more convenient for integration tests + let headers_per_patch = + if self.is_regtest() { HEADERS_PER_BATCH * 10 } else { HEADERS_PER_BATCH }; + + // let futures = (latest_height..latest_height + headers_per_patch ) // .map(|height| async move { // tracing::debug!("fetching height {}", height); // let hash = self.esplora_client.get_block_hash(height).await?; @@ -216,11 +222,10 @@ impl Relayer { // Ok(try_join_all(futures).await?) let bitcoin_height = self.esplora_client.get_chain_height().await?; + tracing::debug!("bitcoin_height {bitcoin_height}"); let mut relay_headers = Vec::new(); - for height in - latest_height..(latest_height + HEADERS_PER_BATCH as u32).min(bitcoin_height + 1) - { + for height in latest_height..(latest_height + headers_per_patch).min(bitcoin_height + 1) { tracing::debug!("fetching height {}", height); let hash = self.esplora_client.get_block_hash(height).await?; let header = self.esplora_client.get_block_header(&hash).await?; @@ -230,6 +235,12 @@ impl Relayer { } async fn push_headers(&self, headers: Vec) -> Result<()> { + if headers.is_empty() { + tracing::debug!("No headers to push.."); + + return Ok(()); + }; + let start_mod = headers.first().unwrap().height % 2016; let end_header = headers.last().unwrap().clone(); let end_mod = end_header.height % 2016; @@ -262,6 +273,12 @@ impl Relayer { tracing::debug!("updating head"); self.update_best_digest(end_header).await?; + tracing::info!( + "Relayed until height {}, with hash {}", + self.relayed_height().await?, + self.relayed_blockhash().await? + ); + Ok(()) } From 7ec814ca68e66e373906cdd9823167569433157e Mon Sep 17 00:00:00 2001 From: nazeh Date: Mon, 16 Jun 2025 10:44:10 +0300 Subject: [PATCH 16/24] feat(relayer): change info! to debug --- relayer/src/relayer.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/relayer/src/relayer.rs b/relayer/src/relayer.rs index a4f982fe5..5df441ed9 100644 --- a/relayer/src/relayer.rs +++ b/relayer/src/relayer.rs @@ -273,7 +273,7 @@ impl Relayer { tracing::debug!("updating head"); self.update_best_digest(end_header).await?; - tracing::info!( + tracing::debug!( "Relayed until height {}, with hash {}", self.relayed_height().await?, self.relayed_blockhash().await? From 2012cf9e394c735546cb0665b6483c38b75f03af Mon Sep 17 00:00:00 2001 From: Nuh Date: Wed, 2 Jul 2025 09:31:40 +0300 Subject: [PATCH 17/24] Update relayer/src/relayer.rs Co-authored-by: sander2 --- relayer/src/relayer.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/relayer/src/relayer.rs b/relayer/src/relayer.rs index 5df441ed9..3e87e0aab 100644 --- a/relayer/src/relayer.rs +++ b/relayer/src/relayer.rs @@ -133,7 +133,7 @@ impl Relayer { } /// Returns the block hash of the most recent relayed block. - pub async fn relayed_blockhash(&self) -> Result { + pub async fn best_blockhash(&self) -> Result { Ok(self .contract .getBestKnownDigest() From e8785daa586e185198fb8005db229dc736ade9eb Mon Sep 17 00:00:00 2001 From: nazeh Date: Wed, 2 Jul 2025 09:34:48 +0300 Subject: [PATCH 18/24] review feedback --- relayer/src/relayer.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/relayer/src/relayer.rs b/relayer/src/relayer.rs index 3e87e0aab..15e241f83 100644 --- a/relayer/src/relayer.rs +++ b/relayer/src/relayer.rs @@ -170,7 +170,7 @@ impl Relayer { return Ok(height); } - tracing::debug!("Found fork: {actual_hash} at height {height}"); + tracing::info!("Found fork: {actual_hash} at height {height}"); if height == 0 { return Err(eyre!("No common height found before reaching 0")); } @@ -196,7 +196,7 @@ impl Relayer { self.push_headers(headers).await?; tokio::time::sleep(if self.is_regtest() { - Duration::from_millis(10) + Duration::from_millis(150) } else { Duration::from_secs(15) }) @@ -276,7 +276,7 @@ impl Relayer { tracing::debug!( "Relayed until height {}, with hash {}", self.relayed_height().await?, - self.relayed_blockhash().await? + self.best_blockhash().await? ); Ok(()) From 1e6ae7ff0cf863c264c822f63cad66412965e692 Mon Sep 17 00:00:00 2001 From: Sander Bosma Date: Wed, 2 Jul 2025 13:53:43 +0200 Subject: [PATCH 19/24] chore: fix clippy --- crates/bindings/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/bindings/src/lib.rs b/crates/bindings/src/lib.rs index 02b886c2c..3b142347a 100644 --- a/crates/bindings/src/lib.rs +++ b/crates/bindings/src/lib.rs @@ -1,4 +1,4 @@ -#![allow(unused_imports, clippy::all, rustdoc::all)] +#![allow(unused_imports, clippy::all, dead_code, rustdoc::all)] //! This module contains the sol! generated bindings for solidity contracts. //! This is autogenerated code. //! Do not manually edit these files. From c63f7e72c81a5df1f42d01a0df400f8ec49f79f5 Mon Sep 17 00:00:00 2001 From: Sander Bosma Date: Wed, 2 Jul 2025 13:59:35 +0200 Subject: [PATCH 20/24] chore: fix clippy --- crates/utils/src/bitcoin_client.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/utils/src/bitcoin_client.rs b/crates/utils/src/bitcoin_client.rs index 050e07d3b..e1ab1a692 100644 --- a/crates/utils/src/bitcoin_client.rs +++ b/crates/utils/src/bitcoin_client.rs @@ -533,11 +533,11 @@ fn create_merkle_branch_and_root( ) -> (Vec, Sha256dHash) { let mut merkle = vec![]; while hashes.len() > 1 { - if hashes.len() % 2 != 0 { + if !hashes.len().is_multiple_of(2) { let last = *hashes.last().unwrap(); hashes.push(last); } - index = if index % 2 == 0 { index + 1 } else { index - 1 }; + index = if index.is_multiple_of(2) { index + 1 } else { index - 1 }; merkle.push(hashes[index]); index /= 2; hashes = hashes.chunks(2).map(|pair| merklize(pair[0], pair[1])).collect() From 1571857cce9c9260e960cc9835f02f36cc7a7567 Mon Sep 17 00:00:00 2001 From: Sander Bosma Date: Wed, 2 Jul 2025 17:58:45 +0200 Subject: [PATCH 21/24] chore: fixed bindings --- crates/bindings/src/address.rs | 215 - crates/bindings/src/arbitary_erc20.rs | 4237 ------- .../bindings/src/avalon_lending_strategy.rs | 1771 --- crates/bindings/src/avalon_lst_strategy.rs | 1812 --- .../avalon_tbtc_lending_strategy_forked.rs | 8013 ------------- .../avalon_wbtc_lending_strategy_forked.rs | 8013 ------------- .../src/avalon_wbtc_lst_strategy_forked.rs | 8004 ------------- crates/bindings/src/bedrock_strategy.rs | 1554 --- .../bindings/src/bedrock_strategy_forked.rs | 7991 ------------- crates/bindings/src/bitcoin_tx.rs | 218 - crates/bindings/src/bitcoin_tx_builder.rs | 1571 --- crates/bindings/src/btc_market_place.rs | 9865 ----------------- crates/bindings/src/btc_utils.rs | 1127 -- crates/bindings/src/bytes_lib.rs | 218 - crates/bindings/src/constants.rs | 218 - crates/bindings/src/context.rs | 215 - .../src/dummy_avalon_pool_implementation.rs | 940 -- .../src/dummy_bedrock_vault_implementation.rs | 1060 -- crates/bindings/src/dummy_ionic_pool.rs | 842 -- crates/bindings/src/dummy_ionic_token.rs | 4713 -------- crates/bindings/src/dummy_pell_strategy.rs | 218 - .../src/dummy_pell_strategy_manager.rs | 838 -- crates/bindings/src/dummy_se_bep20.rs | 5161 --------- crates/bindings/src/dummy_shoe_bill_token.rs | 4696 -------- crates/bindings/src/dummy_solv_router.rs | 679 -- crates/bindings/src/erc20.rs | 3224 ------ crates/bindings/src/erc2771_recipient.rs | 735 -- .../src/forked_strategy_template_tbtc.rs | 7635 ------------- .../src/forked_strategy_template_wbtc.rs | 7635 ------------- crates/bindings/src/hybrid_btc_strategy.rs | 1788 --- .../src/hybrid_btc_strategy_forked_wbtc.rs | 8360 -------------- crates/bindings/src/i_avalon_i_pool.rs | 808 -- crates/bindings/src/i_bedrock_vault.rs | 924 -- crates/bindings/src/i_ionic_token.rs | 719 -- crates/bindings/src/i_light_relay.rs | 2550 ----- crates/bindings/src/i_pell_strategy.rs | 218 - .../bindings/src/i_pell_strategy_manager.rs | 841 -- crates/bindings/src/i_pool.rs | 740 -- crates/bindings/src/i_se_bep20.rs | 1185 -- crates/bindings/src/i_solv_btc_router.rs | 553 - crates/bindings/src/i_strategy.rs | 782 -- .../src/i_strategy_with_slippage_args.rs | 1275 --- crates/bindings/src/i_teller.rs | 547 - crates/bindings/src/ic_erc20.rs | 729 -- crates/bindings/src/ierc20.rs | 2049 ---- crates/bindings/src/ierc20_metadata.rs | 2650 ----- crates/bindings/src/ierc2771_recipient.rs | 527 - crates/bindings/src/ionic_strategy.rs | 1767 --- crates/bindings/src/ionic_strategy_forked.rs | 7991 ------------- crates/bindings/src/lib.rs | 80 +- crates/bindings/src/light_relay.rs | 6027 ---------- crates/bindings/src/market_place.rs | 3197 ------ crates/bindings/src/ord_marketplace.rs | 6113 ---------- crates/bindings/src/ownable.rs | 1104 -- .../src/pell_bed_rock_lst_strategy_forked.rs | 8010 ------------- .../src/pell_bed_rock_strategy_forked.rs | 7998 ------------- crates/bindings/src/pell_bedrock_strategy.rs | 1808 --- crates/bindings/src/pell_solv_lst_strategy.rs | 1808 --- crates/bindings/src/pell_strategy.rs | 2032 ---- crates/bindings/src/pell_strategy_forked.rs | 7991 ------------- crates/bindings/src/relay_utils.rs | 218 - crates/bindings/src/safe_erc20.rs | 218 - crates/bindings/src/safe_math.rs | 218 - crates/bindings/src/seg_wit_utils.rs | 723 -- ...segment_bedrock_and_lst_strategy_forked.rs | 8308 -------------- .../bindings/src/segment_bedrock_strategy.rs | 1810 --- .../bindings/src/segment_solv_lst_strategy.rs | 1810 --- crates/bindings/src/segment_strategy.rs | 1554 --- .../bindings/src/segment_strategy_forked.rs | 7991 ------------- crates/bindings/src/shoebill_strategy.rs | 1554 --- .../src/shoebill_tbtc_strategy_forked.rs | 8006 ------------- crates/bindings/src/solv_btc_strategy.rs | 2006 ---- crates/bindings/src/solv_lst_strategy.rs | 2695 ----- crates/bindings/src/solv_strategy_forked.rs | 8183 -------------- crates/bindings/src/std_constants.rs | 218 - crates/bindings/src/strings.rs | 215 - crates/bindings/src/utilities.rs | 3808 ------- crates/bindings/src/validate_spv.rs | 218 - crates/bindings/src/witness_tx.rs | 218 - 79 files changed, 1 insertion(+), 226559 deletions(-) delete mode 100644 crates/bindings/src/address.rs delete mode 100644 crates/bindings/src/arbitary_erc20.rs delete mode 100644 crates/bindings/src/avalon_lending_strategy.rs delete mode 100644 crates/bindings/src/avalon_lst_strategy.rs delete mode 100644 crates/bindings/src/avalon_tbtc_lending_strategy_forked.rs delete mode 100644 crates/bindings/src/avalon_wbtc_lending_strategy_forked.rs delete mode 100644 crates/bindings/src/avalon_wbtc_lst_strategy_forked.rs delete mode 100644 crates/bindings/src/bedrock_strategy.rs delete mode 100644 crates/bindings/src/bedrock_strategy_forked.rs delete mode 100644 crates/bindings/src/bitcoin_tx.rs delete mode 100644 crates/bindings/src/bitcoin_tx_builder.rs delete mode 100644 crates/bindings/src/btc_market_place.rs delete mode 100644 crates/bindings/src/btc_utils.rs delete mode 100644 crates/bindings/src/bytes_lib.rs delete mode 100644 crates/bindings/src/constants.rs delete mode 100644 crates/bindings/src/context.rs delete mode 100644 crates/bindings/src/dummy_avalon_pool_implementation.rs delete mode 100644 crates/bindings/src/dummy_bedrock_vault_implementation.rs delete mode 100644 crates/bindings/src/dummy_ionic_pool.rs delete mode 100644 crates/bindings/src/dummy_ionic_token.rs delete mode 100644 crates/bindings/src/dummy_pell_strategy.rs delete mode 100644 crates/bindings/src/dummy_pell_strategy_manager.rs delete mode 100644 crates/bindings/src/dummy_se_bep20.rs delete mode 100644 crates/bindings/src/dummy_shoe_bill_token.rs delete mode 100644 crates/bindings/src/dummy_solv_router.rs delete mode 100644 crates/bindings/src/erc20.rs delete mode 100644 crates/bindings/src/erc2771_recipient.rs delete mode 100644 crates/bindings/src/forked_strategy_template_tbtc.rs delete mode 100644 crates/bindings/src/forked_strategy_template_wbtc.rs delete mode 100644 crates/bindings/src/hybrid_btc_strategy.rs delete mode 100644 crates/bindings/src/hybrid_btc_strategy_forked_wbtc.rs delete mode 100644 crates/bindings/src/i_avalon_i_pool.rs delete mode 100644 crates/bindings/src/i_bedrock_vault.rs delete mode 100644 crates/bindings/src/i_ionic_token.rs delete mode 100644 crates/bindings/src/i_light_relay.rs delete mode 100644 crates/bindings/src/i_pell_strategy.rs delete mode 100644 crates/bindings/src/i_pell_strategy_manager.rs delete mode 100644 crates/bindings/src/i_pool.rs delete mode 100644 crates/bindings/src/i_se_bep20.rs delete mode 100644 crates/bindings/src/i_solv_btc_router.rs delete mode 100644 crates/bindings/src/i_strategy.rs delete mode 100644 crates/bindings/src/i_strategy_with_slippage_args.rs delete mode 100644 crates/bindings/src/i_teller.rs delete mode 100644 crates/bindings/src/ic_erc20.rs delete mode 100644 crates/bindings/src/ierc20.rs delete mode 100644 crates/bindings/src/ierc20_metadata.rs delete mode 100644 crates/bindings/src/ierc2771_recipient.rs delete mode 100644 crates/bindings/src/ionic_strategy.rs delete mode 100644 crates/bindings/src/ionic_strategy_forked.rs delete mode 100644 crates/bindings/src/light_relay.rs delete mode 100644 crates/bindings/src/market_place.rs delete mode 100644 crates/bindings/src/ord_marketplace.rs delete mode 100644 crates/bindings/src/ownable.rs delete mode 100644 crates/bindings/src/pell_bed_rock_lst_strategy_forked.rs delete mode 100644 crates/bindings/src/pell_bed_rock_strategy_forked.rs delete mode 100644 crates/bindings/src/pell_bedrock_strategy.rs delete mode 100644 crates/bindings/src/pell_solv_lst_strategy.rs delete mode 100644 crates/bindings/src/pell_strategy.rs delete mode 100644 crates/bindings/src/pell_strategy_forked.rs delete mode 100644 crates/bindings/src/relay_utils.rs delete mode 100644 crates/bindings/src/safe_erc20.rs delete mode 100644 crates/bindings/src/safe_math.rs delete mode 100644 crates/bindings/src/seg_wit_utils.rs delete mode 100644 crates/bindings/src/segment_bedrock_and_lst_strategy_forked.rs delete mode 100644 crates/bindings/src/segment_bedrock_strategy.rs delete mode 100644 crates/bindings/src/segment_solv_lst_strategy.rs delete mode 100644 crates/bindings/src/segment_strategy.rs delete mode 100644 crates/bindings/src/segment_strategy_forked.rs delete mode 100644 crates/bindings/src/shoebill_strategy.rs delete mode 100644 crates/bindings/src/shoebill_tbtc_strategy_forked.rs delete mode 100644 crates/bindings/src/solv_btc_strategy.rs delete mode 100644 crates/bindings/src/solv_lst_strategy.rs delete mode 100644 crates/bindings/src/solv_strategy_forked.rs delete mode 100644 crates/bindings/src/std_constants.rs delete mode 100644 crates/bindings/src/strings.rs delete mode 100644 crates/bindings/src/utilities.rs delete mode 100644 crates/bindings/src/validate_spv.rs delete mode 100644 crates/bindings/src/witness_tx.rs diff --git a/crates/bindings/src/address.rs b/crates/bindings/src/address.rs deleted file mode 100644 index 985c80231..000000000 --- a/crates/bindings/src/address.rs +++ /dev/null @@ -1,215 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface Address {} -``` - -...which was generated by the following JSON ABI: -```json -[] -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod Address { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122066b802c23a5c4d43f9b40fc6e1048fe03bb91dfb723ee13b98711fa15c7165a364736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"`U`2`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`&WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 f\xB8\x02\xC2:\\MC\xF9\xB4\x0F\xC6\xE1\x04\x8F\xE0;\xB9\x1D\xFBr>\xE1;\x98q\x1F\xA1\\qe\xA3dsolcC\0\x08\x1C\x003", - ); - /// The runtime bytecode of the contract, as deployed on the network. - /// - /// ```text - ///0x730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122066b802c23a5c4d43f9b40fc6e1048fe03bb91dfb723ee13b98711fa15c7165a364736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 f\xB8\x02\xC2:\\MC\xF9\xB4\x0F\xC6\xE1\x04\x8F\xE0;\xB9\x1D\xFBr>\xE1;\x98q\x1F\xA1\\qe\xA3dsolcC\0\x08\x1C\x003", - ); - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`Address`](self) contract instance. - -See the [wrapper's documentation](`AddressInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >(address: alloy_sol_types::private::Address, provider: P) -> AddressInstance { - AddressInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - AddressInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - AddressInstance::::deploy_builder(provider) - } - /**A [`Address`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`Address`](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 AddressInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for AddressInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("AddressInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > AddressInstance { - /**Creates a new wrapper around an on-chain [`Address`](self) contract instance. - -See the [wrapper's documentation](`AddressInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 AddressInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> AddressInstance { - AddressInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > AddressInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > AddressInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/arbitary_erc20.rs b/crates/bindings/src/arbitary_erc20.rs deleted file mode 100644 index 3b5ebe881..000000000 --- a/crates/bindings/src/arbitary_erc20.rs +++ /dev/null @@ -1,4237 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface ArbitaryErc20 { - event Approval(address indexed owner, address indexed spender, uint256 value); - event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); - 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 owner() external view returns (address); - function renounceOwnership() external; - function sudoMint(address to, uint256 amount) external; - function symbol() external view returns (string memory); - function totalSupply() external view returns (uint256); - function transfer(address to, uint256 amount) external returns (bool); - function transferFrom(address from, address to, uint256 amount) external returns (bool); - function transferOwnership(address newOwner) external; -} -``` - -...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": "owner", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "address" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "renounceOwnership", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "sudoMint", - "inputs": [ - { - "name": "to", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "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": "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" - }, - { - "type": "function", - "name": "transferOwnership", - "inputs": [ - { - "name": "newOwner", - "type": "address", - "internalType": "address" - } - ], - "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": "OwnershipTransferred", - "inputs": [ - { - "name": "previousOwner", - "type": "address", - "indexed": true, - "internalType": "address" - }, - { - "name": "newOwner", - "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 ArbitaryErc20 { - use super::*; - use alloy::sol_types as 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__\xFD[P`@Qa\x10#8\x03\x80a\x10#\x839\x81\x01`@\x81\x90Ra\0.\x91a\x01[V[\x81\x81`\x03a\0<\x83\x82a\x02DV[P`\x04a\0I\x82\x82a\x02DV[PPPa\0ba\0]a\0i` \x1B` \x1CV[a\0mV[PPa\x02\xFEV[3\x90V[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x01`\x01`\xA0\x1B\x03\x19\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x82`\x1F\x83\x01\x12a\0\xE1W__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\0\xFAWa\0\xFAa\0\xBEV[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x01(Wa\x01(a\0\xBEV[`@R\x81\x81R\x83\x82\x01` \x01\x85\x10\x15a\x01?W__\xFD[\x81` \x85\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[__`@\x83\x85\x03\x12\x15a\x01lW__\xFD[\x82Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\x81W__\xFD[a\x01\x8D\x85\x82\x86\x01a\0\xD2V[` \x85\x01Q\x90\x93P\x90P`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\xAAW__\xFD[a\x01\xB6\x85\x82\x86\x01a\0\xD2V[\x91PP\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x01\xD4W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x01\xF2WcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\x02?W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x02\x1DWP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x02\x14a\x02\nW\x80c\xF2\xFD\xE3\x8B\x14a\x02BW__\xFD[\x80cp\xA0\x821\x14a\x01\x91W\x80cqP\x18\xA6\x14a\x01\xB9W\x80c\x8D\xA5\xCB[\x14a\x01\xC1W\x80c\x95\xD8\x9BA\x14a\x01\xDCW__\xFD[\x80c#\xB8r\xDD\x11a\0\xCEW\x80c#\xB8r\xDD\x14a\x01GW\x80c-h\x8C\xA8\x14a\x01ZW\x80c1<\xE5g\x14a\x01oW\x80c9P\x93Q\x14a\x01~W__\xFD[\x80c\x06\xFD\xDE\x03\x14a\0\xF4W\x80c\t^\xA7\xB3\x14a\x01\x12W\x80c\x18\x16\r\xDD\x14a\x015W[__\xFD[a\0\xFCa\x02UV[`@Qa\x01\t\x91\x90a\x0B8V[`@Q\x80\x91\x03\x90\xF3[a\x01%a\x01 6`\x04a\x0B\xA6V[a\x02\xE5V[`@Q\x90\x15\x15\x81R` \x01a\x01\tV[`\x02T[`@Q\x90\x81R` \x01a\x01\tV[a\x01%a\x01U6`\x04a\x0B\xCEV[a\x02\xFEV[a\x01ma\x01h6`\x04a\x0B\xA6V[a\x03!V[\0[`@Q`\x12\x81R` \x01a\x01\tV[a\x01%a\x01\x8C6`\x04a\x0B\xA6V[a\x03\x8EV[a\x019a\x01\x9F6`\x04a\x0C\x08V[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R` \x81\x90R`@\x90 T\x90V[a\x01ma\x03\xCCV[`\x05T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01\tV[a\0\xFCa\x041V[a\x01%a\x01\xF26`\x04a\x0B\xA6V[a\x04@V[a\x01%a\x02\x056`\x04a\x0B\xA6V[a\x04\xE9V[a\x019a\x02\x186`\x04a\x0C(V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[a\x01ma\x02P6`\x04a\x0C\x08V[a\x04\xF6V[```\x03\x80Ta\x02d\x90a\x0CYV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\x90\x90a\x0CYV[\x80\x15a\x02\xDBW\x80`\x1F\x10a\x02\xB2Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02\xDBV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02\xBEW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[_3a\x02\xF2\x81\x85\x85a\x05\xD8V[`\x01\x91PP[\x92\x91PPV[_3a\x03\x0B\x85\x82\x85a\x07/V[a\x03\x16\x85\x85\x85a\x07\xDEV[P`\x01\x94\x93PPPPV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x03\x80W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\x8A\x82\x82a\t\xF3V[PPV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90a\x02\xF2\x90\x82\x90\x86\x90a\x03\xC7\x90\x87\x90a\x0C\xAAV[a\x05\xD8V[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x04&W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03wV[a\x04/_a\n\xCFV[V[```\x04\x80Ta\x02d\x90a\x0CYV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90\x83\x81\x10\x15a\x04\xDCW`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[a\x03\x16\x82\x86\x86\x84\x03a\x05\xD8V[_3a\x02\xF2\x81\x85\x85a\x07\xDEV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x05PW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03wV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x05\xCCW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01R\x7Fddress\0\0\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\x03wV[a\x05\xD5\x81a\n\xCFV[PV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x06SW`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x06\xCFW`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\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[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R 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\x81\x14a\x07\xD8W\x81\x81\x10\x15a\x07\xCBW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FERC20: insufficient allowance\0\0\0`D\x82\x01R`d\x01a\x03wV[a\x07\xD8\x84\x84\x84\x84\x03a\x05\xD8V[PPPPV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x08ZW`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x08\xD6W`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R` \x81\x90R`@\x90 T\x81\x81\x10\x15a\tdW`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16_\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R\x90\x81 \x80T\x84\x92\x90a\t\x9A\x90\x84\x90a\x0C\xAAV[\x92PP\x81\x90UP\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\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\t\xE6\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3a\x07\xD8V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\nIW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FERC20: mint to the zero address\0`D\x82\x01R`d\x01a\x03wV[\x80`\x02_\x82\x82Ta\nZ\x91\x90a\x0C\xAAV[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x83\x92\x90a\n\x86\x90\x84\x90a\x0C\xAAV[\x90\x91UPP`@Q\x81\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90_\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[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\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\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\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\x84\x01\x01\x91PP\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0B\xA1W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0B\xB7W__\xFD[a\x0B\xC0\x83a\x0B\x8BV[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x0B\xE0W__\xFD[a\x0B\xE9\x84a\x0B\x8BV[\x92Pa\x0B\xF7` \x85\x01a\x0B\x8BV[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\x0C\x18W__\xFD[a\x0C!\x82a\x0B\x8BV[\x93\x92PPPV[__`@\x83\x85\x03\x12\x15a\x0C9W__\xFD[a\x0CB\x83a\x0B\x8BV[\x91Pa\x0CP` \x84\x01a\x0B\x8BV[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x0CmW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x0C\xA4W\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[P\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02\xF8W\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\xFE\xA2dipfsX\"\x12 6bhE\x12\x8Ff\xB6f-^\xA0\xFB}\xA1\x12\x14a\x02\nW\x80c\xF2\xFD\xE3\x8B\x14a\x02BW__\xFD[\x80cp\xA0\x821\x14a\x01\x91W\x80cqP\x18\xA6\x14a\x01\xB9W\x80c\x8D\xA5\xCB[\x14a\x01\xC1W\x80c\x95\xD8\x9BA\x14a\x01\xDCW__\xFD[\x80c#\xB8r\xDD\x11a\0\xCEW\x80c#\xB8r\xDD\x14a\x01GW\x80c-h\x8C\xA8\x14a\x01ZW\x80c1<\xE5g\x14a\x01oW\x80c9P\x93Q\x14a\x01~W__\xFD[\x80c\x06\xFD\xDE\x03\x14a\0\xF4W\x80c\t^\xA7\xB3\x14a\x01\x12W\x80c\x18\x16\r\xDD\x14a\x015W[__\xFD[a\0\xFCa\x02UV[`@Qa\x01\t\x91\x90a\x0B8V[`@Q\x80\x91\x03\x90\xF3[a\x01%a\x01 6`\x04a\x0B\xA6V[a\x02\xE5V[`@Q\x90\x15\x15\x81R` \x01a\x01\tV[`\x02T[`@Q\x90\x81R` \x01a\x01\tV[a\x01%a\x01U6`\x04a\x0B\xCEV[a\x02\xFEV[a\x01ma\x01h6`\x04a\x0B\xA6V[a\x03!V[\0[`@Q`\x12\x81R` \x01a\x01\tV[a\x01%a\x01\x8C6`\x04a\x0B\xA6V[a\x03\x8EV[a\x019a\x01\x9F6`\x04a\x0C\x08V[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R` \x81\x90R`@\x90 T\x90V[a\x01ma\x03\xCCV[`\x05T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01\tV[a\0\xFCa\x041V[a\x01%a\x01\xF26`\x04a\x0B\xA6V[a\x04@V[a\x01%a\x02\x056`\x04a\x0B\xA6V[a\x04\xE9V[a\x019a\x02\x186`\x04a\x0C(V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[a\x01ma\x02P6`\x04a\x0C\x08V[a\x04\xF6V[```\x03\x80Ta\x02d\x90a\x0CYV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\x90\x90a\x0CYV[\x80\x15a\x02\xDBW\x80`\x1F\x10a\x02\xB2Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02\xDBV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02\xBEW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[_3a\x02\xF2\x81\x85\x85a\x05\xD8V[`\x01\x91PP[\x92\x91PPV[_3a\x03\x0B\x85\x82\x85a\x07/V[a\x03\x16\x85\x85\x85a\x07\xDEV[P`\x01\x94\x93PPPPV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x03\x80W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\x8A\x82\x82a\t\xF3V[PPV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90a\x02\xF2\x90\x82\x90\x86\x90a\x03\xC7\x90\x87\x90a\x0C\xAAV[a\x05\xD8V[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x04&W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03wV[a\x04/_a\n\xCFV[V[```\x04\x80Ta\x02d\x90a\x0CYV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90\x83\x81\x10\x15a\x04\xDCW`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[a\x03\x16\x82\x86\x86\x84\x03a\x05\xD8V[_3a\x02\xF2\x81\x85\x85a\x07\xDEV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x05PW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03wV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x05\xCCW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01R\x7Fddress\0\0\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\x03wV[a\x05\xD5\x81a\n\xCFV[PV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x06SW`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x06\xCFW`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\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[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R 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\x81\x14a\x07\xD8W\x81\x81\x10\x15a\x07\xCBW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FERC20: insufficient allowance\0\0\0`D\x82\x01R`d\x01a\x03wV[a\x07\xD8\x84\x84\x84\x84\x03a\x05\xD8V[PPPPV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x08ZW`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x08\xD6W`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R` \x81\x90R`@\x90 T\x81\x81\x10\x15a\tdW`@QbF\x1B\xCD`\xE5\x1B\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\x03wV[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16_\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R\x90\x81 \x80T\x84\x92\x90a\t\x9A\x90\x84\x90a\x0C\xAAV[\x92PP\x81\x90UP\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\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\t\xE6\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3a\x07\xD8V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\nIW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FERC20: mint to the zero address\0`D\x82\x01R`d\x01a\x03wV[\x80`\x02_\x82\x82Ta\nZ\x91\x90a\x0C\xAAV[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x83\x92\x90a\n\x86\x90\x84\x90a\x0C\xAAV[\x90\x91UPP`@Q\x81\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90_\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[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\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\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\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\x84\x01\x01\x91PP\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0B\xA1W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0B\xB7W__\xFD[a\x0B\xC0\x83a\x0B\x8BV[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x0B\xE0W__\xFD[a\x0B\xE9\x84a\x0B\x8BV[\x92Pa\x0B\xF7` \x85\x01a\x0B\x8BV[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\x0C\x18W__\xFD[a\x0C!\x82a\x0B\x8BV[\x93\x92PPPV[__`@\x83\x85\x03\x12\x15a\x0C9W__\xFD[a\x0CB\x83a\x0B\x8BV[\x91Pa\x0CP` \x84\x01a\x0B\x8BV[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x0CmW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x0C\xA4W\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[P\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02\xF8W\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\xFE\xA2dipfsX\"\x12 6bhE\x12\x8Ff\xB6f-^\xA0\xFB}\xA1\x12 = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - 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, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - owner: topics.1, - spender: topics.2, - value: data.0, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.value), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = ::encode_topic( - &self.owner, - ); - out[2usize] = ::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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for OwnershipTransferred { - type DataTuple<'a> = (); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - 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, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - previousOwner: topics.1, - newOwner: topics.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return 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) -> ::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() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = ::encode_topic( - &self.previousOwner, - ); - out[2usize] = ::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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for Transfer { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - 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, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - from: topics.1, - to: topics.2, - value: data.0, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.value), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = ::encode_topic( - &self.from, - ); - out[2usize] = ::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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value.name_, value.symbol_) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.name_, - ), - ::tokenize( - &self.symbol_, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: allowanceCall) -> Self { - (value.owner, value.spender) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for allowanceCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - owner: tuple.0, - spender: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: allowanceReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "allowance(address,address)"; - const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.owner, - ), - ::tokenize( - &self.spender, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: allowanceReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: approveCall) -> Self { - (value.spender, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for approveCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - spender: tuple.0, - amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: approveReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "approve(address,uint256)"; - const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.spender, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: approveReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: balanceOfCall) -> Self { - (value.account,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for balanceOfCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { account: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: balanceOfReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "balanceOf(address)"; - const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.account, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: balanceOfReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: decimalsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for decimalsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: decimalsReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for decimalsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for decimalsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = u8; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "decimals()"; - const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: decimalsReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: decreaseAllowanceCall) -> Self { - (value.spender, value.subtractedValue) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for decreaseAllowanceCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - spender: tuple.0, - subtractedValue: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: decreaseAllowanceReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)"; - const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.spender, - ), - as alloy_sol_types::SolType>::tokenize(&self.subtractedValue), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: decreaseAllowanceReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: increaseAllowanceCall) -> Self { - (value.spender, value.addedValue) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for increaseAllowanceCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - spender: tuple.0, - addedValue: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: increaseAllowanceReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "increaseAllowance(address,uint256)"; - const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.spender, - ), - as alloy_sol_types::SolType>::tokenize(&self.addedValue), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: increaseAllowanceReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: nameCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for nameCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: nameReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for nameReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for nameCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::String; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "name()"; - const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: nameReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: ownerCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for ownerCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: ownerReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for ownerReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for ownerCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "owner()"; - const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: ownerReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: renounceOwnershipCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for renounceOwnershipCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: renounceOwnershipReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for renounceOwnershipReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl renounceOwnershipReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for renounceOwnershipCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = renounceOwnershipReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "renounceOwnership()"; - const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8]; - #[inline] - fn new<'a>( - tuple: 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 { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `sudoMint(address,uint256)` and selector `0x2d688ca8`. -```solidity -function sudoMint(address to, uint256 amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct sudoMintCall { - #[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 [`sudoMint(address,uint256)`](sudoMintCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct sudoMintReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: sudoMintCall) -> Self { - (value.to, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for sudoMintCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - to: tuple.0, - amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: sudoMintReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for sudoMintReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl sudoMintReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for sudoMintCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = sudoMintReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "sudoMint(address,uint256)"; - const SELECTOR: [u8; 4] = [45u8, 104u8, 140u8, 168u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.to, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - sudoMintReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: symbolCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for symbolCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: symbolReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for symbolReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for symbolCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::String; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "symbol()"; - const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: symbolReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: totalSupplyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for totalSupplyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: totalSupplyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for totalSupplyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for totalSupplyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "totalSupply()"; - const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: totalSupplyReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferCall) -> Self { - (value.to, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for transferCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - to: tuple.0, - amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "transfer(address,uint256)"; - const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.to, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: transferReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferFromCall) -> Self { - (value.from, value.to, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for transferFromCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - from: tuple.0, - to: tuple.1, - amount: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferFromReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "transferFrom(address,address,uint256)"; - const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.from, - ), - ::tokenize( - &self.to, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: transferFromReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: transferOwnershipCall) -> Self { - (value.newOwner,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for transferOwnershipCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { newOwner: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: transferOwnershipReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for transferOwnershipReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl transferOwnershipReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for transferOwnershipCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = transferOwnershipReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "transferOwnership(address)"; - const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::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 { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`ArbitaryErc20`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum ArbitaryErc20Calls { - #[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)] - owner(ownerCall), - #[allow(missing_docs)] - renounceOwnership(renounceOwnershipCall), - #[allow(missing_docs)] - sudoMint(sudoMintCall), - #[allow(missing_docs)] - symbol(symbolCall), - #[allow(missing_docs)] - totalSupply(totalSupplyCall), - #[allow(missing_docs)] - transfer(transferCall), - #[allow(missing_docs)] - transferFrom(transferFromCall), - #[allow(missing_docs)] - transferOwnership(transferOwnershipCall), - } - #[automatically_derived] - impl ArbitaryErc20Calls { - /// 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], - [45u8, 104u8, 140u8, 168u8], - [49u8, 60u8, 229u8, 103u8], - [57u8, 80u8, 147u8, 81u8], - [112u8, 160u8, 130u8, 49u8], - [113u8, 80u8, 24u8, 166u8], - [141u8, 165u8, 203u8, 91u8], - [149u8, 216u8, 155u8, 65u8], - [164u8, 87u8, 194u8, 215u8], - [169u8, 5u8, 156u8, 187u8], - [221u8, 98u8, 237u8, 62u8], - [242u8, 253u8, 227u8, 139u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for ArbitaryErc20Calls { - const NAME: &'static str = "ArbitaryErc20Calls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 15usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::allowance(_) => { - ::SELECTOR - } - Self::approve(_) => ::SELECTOR, - Self::balanceOf(_) => { - ::SELECTOR - } - Self::decimals(_) => ::SELECTOR, - Self::decreaseAllowance(_) => { - ::SELECTOR - } - Self::increaseAllowance(_) => { - ::SELECTOR - } - Self::name(_) => ::SELECTOR, - Self::owner(_) => ::SELECTOR, - Self::renounceOwnership(_) => { - ::SELECTOR - } - Self::sudoMint(_) => ::SELECTOR, - Self::symbol(_) => ::SELECTOR, - Self::totalSupply(_) => { - ::SELECTOR - } - Self::transfer(_) => ::SELECTOR, - Self::transferFrom(_) => { - ::SELECTOR - } - Self::transferOwnership(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn name(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ArbitaryErc20Calls::name) - } - name - }, - { - fn approve( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ArbitaryErc20Calls::approve) - } - approve - }, - { - fn totalSupply( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ArbitaryErc20Calls::totalSupply) - } - totalSupply - }, - { - fn transferFrom( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ArbitaryErc20Calls::transferFrom) - } - transferFrom - }, - { - fn sudoMint( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ArbitaryErc20Calls::sudoMint) - } - sudoMint - }, - { - fn decimals( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ArbitaryErc20Calls::decimals) - } - decimals - }, - { - fn increaseAllowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ArbitaryErc20Calls::increaseAllowance) - } - increaseAllowance - }, - { - fn balanceOf( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ArbitaryErc20Calls::balanceOf) - } - balanceOf - }, - { - fn renounceOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ArbitaryErc20Calls::renounceOwnership) - } - renounceOwnership - }, - { - fn owner( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ArbitaryErc20Calls::owner) - } - owner - }, - { - fn symbol( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ArbitaryErc20Calls::symbol) - } - symbol - }, - { - fn decreaseAllowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ArbitaryErc20Calls::decreaseAllowance) - } - decreaseAllowance - }, - { - fn transfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ArbitaryErc20Calls::transfer) - } - transfer - }, - { - fn allowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ArbitaryErc20Calls::allowance) - } - allowance - }, - { - fn transferOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ArbitaryErc20Calls::transferOwnership) - } - transferOwnership - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn name(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ArbitaryErc20Calls::name) - } - name - }, - { - fn approve( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ArbitaryErc20Calls::approve) - } - approve - }, - { - fn totalSupply( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ArbitaryErc20Calls::totalSupply) - } - totalSupply - }, - { - fn transferFrom( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ArbitaryErc20Calls::transferFrom) - } - transferFrom - }, - { - fn sudoMint( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ArbitaryErc20Calls::sudoMint) - } - sudoMint - }, - { - fn decimals( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ArbitaryErc20Calls::decimals) - } - decimals - }, - { - fn increaseAllowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ArbitaryErc20Calls::increaseAllowance) - } - increaseAllowance - }, - { - fn balanceOf( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ArbitaryErc20Calls::balanceOf) - } - balanceOf - }, - { - fn renounceOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ArbitaryErc20Calls::renounceOwnership) - } - renounceOwnership - }, - { - fn owner( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ArbitaryErc20Calls::owner) - } - owner - }, - { - fn symbol( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ArbitaryErc20Calls::symbol) - } - symbol - }, - { - fn decreaseAllowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ArbitaryErc20Calls::decreaseAllowance) - } - decreaseAllowance - }, - { - fn transfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ArbitaryErc20Calls::transfer) - } - transfer - }, - { - fn allowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ArbitaryErc20Calls::allowance) - } - allowance - }, - { - fn transferOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ArbitaryErc20Calls::transferOwnership) - } - transferOwnership - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::allowance(inner) => { - ::abi_encoded_size(inner) - } - Self::approve(inner) => { - ::abi_encoded_size(inner) - } - Self::balanceOf(inner) => { - ::abi_encoded_size(inner) - } - Self::decimals(inner) => { - ::abi_encoded_size(inner) - } - Self::decreaseAllowance(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::increaseAllowance(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::name(inner) => { - ::abi_encoded_size(inner) - } - Self::owner(inner) => { - ::abi_encoded_size(inner) - } - Self::renounceOwnership(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::sudoMint(inner) => { - ::abi_encoded_size(inner) - } - Self::symbol(inner) => { - ::abi_encoded_size(inner) - } - Self::totalSupply(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::transfer(inner) => { - ::abi_encoded_size(inner) - } - Self::transferFrom(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::transferOwnership(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::allowance(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::approve(inner) => { - ::abi_encode_raw(inner, out) - } - Self::balanceOf(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::decimals(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::decreaseAllowance(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::increaseAllowance(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::name(inner) => { - ::abi_encode_raw(inner, out) - } - Self::owner(inner) => { - ::abi_encode_raw(inner, out) - } - Self::renounceOwnership(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::sudoMint(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::symbol(inner) => { - ::abi_encode_raw(inner, out) - } - Self::totalSupply(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::transfer(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::transferFrom(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::transferOwnership(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`ArbitaryErc20`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum ArbitaryErc20Events { - #[allow(missing_docs)] - Approval(Approval), - #[allow(missing_docs)] - OwnershipTransferred(OwnershipTransferred), - #[allow(missing_docs)] - Transfer(Transfer), - } - #[automatically_derived] - impl ArbitaryErc20Events { - /// 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]] = &[ - [ - 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, 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, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for ArbitaryErc20Events { - const NAME: &'static str = "ArbitaryErc20Events"; - const COUNT: usize = 3usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::Approval) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::OwnershipTransferred) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::Transfer) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 ArbitaryErc20Events { - 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::OwnershipTransferred(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::OwnershipTransferred(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 as alloy_contract; - /**Creates a new wrapper around an on-chain [`ArbitaryErc20`](self) contract instance. - -See the [wrapper's documentation](`ArbitaryErc20Instance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> ArbitaryErc20Instance { - ArbitaryErc20Instance::::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: alloy_contract::private::Network, - >( - provider: P, - name_: alloy::sol_types::private::String, - symbol_: alloy::sol_types::private::String, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - ArbitaryErc20Instance::::deploy(provider, name_, symbol_) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - name_: alloy::sol_types::private::String, - symbol_: alloy::sol_types::private::String, - ) -> alloy_contract::RawCallBuilder { - ArbitaryErc20Instance::::deploy_builder(provider, name_, symbol_) - } - /**A [`ArbitaryErc20`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`ArbitaryErc20`](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 ArbitaryErc20Instance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for ArbitaryErc20Instance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("ArbitaryErc20Instance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ArbitaryErc20Instance { - /**Creates a new wrapper around an on-chain [`ArbitaryErc20`](self) contract instance. - -See the [wrapper's documentation](`ArbitaryErc20Instance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - name_: alloy::sol_types::private::String, - symbol_: alloy::sol_types::private::String, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder(provider, name_, symbol_); - 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, - name_: alloy::sol_types::private::String, - symbol_: alloy::sol_types::private::String, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { name_, symbol_ }, - )[..], - ] - .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 ArbitaryErc20Instance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> ArbitaryErc20Instance { - ArbitaryErc20Instance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ArbitaryErc20Instance { - /// 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( - &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 [`owner`] function. - pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> { - self.call_builder(&ownerCall) - } - ///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 [`sudoMint`] function. - pub fn sudoMint( - &self, - to: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, sudoMintCall, N> { - self.call_builder(&sudoMintCall { to, amount }) - } - ///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, - 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, - }, - ) - } - ///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. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ArbitaryErc20Instance { - /// 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( - &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::() - } - ///Creates a new event filter for the [`OwnershipTransferred`] event. - pub fn OwnershipTransferred_filter( - &self, - ) -> alloy_contract::Event<&P, OwnershipTransferred, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`Transfer`] event. - pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/avalon_lending_strategy.rs b/crates/bindings/src/avalon_lending_strategy.rs deleted file mode 100644 index fbe8267ea..000000000 --- a/crates/bindings/src/avalon_lending_strategy.rs +++ /dev/null @@ -1,1771 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface AvalonLendingStrategy { - struct StrategySlippageArgs { - uint256 amountOutMin; - } - - event TokenOutput(address tokenReceived, uint256 amountOut); - - constructor(address _avBep20, address _pool); - - function avBep20() external view returns (address); - function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; - function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; - function pool() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "_avBep20", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "_pool", - "type": "address", - "internalType": "contract IAvalonIPool" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "avBep20", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IERC20" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "handleGatewayMessage", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "message", - "type": "bytes", - "internalType": "bytes" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessageWithSlippageArgs", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "args", - "type": "tuple", - "internalType": "struct StrategySlippageArgs", - "components": [ - { - "name": "amountOutMin", - "type": "uint256", - "internalType": "uint256" - } - ] - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "pool", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IAvalonIPool" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "TokenOutput", - "inputs": [ - { - "name": "tokenReceived", - "type": "address", - "indexed": false, - "internalType": "address" - }, - { - "name": "amountOut", - "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 AvalonLendingStrategy { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x60c060405234801561000f575f5ffd5b50604051610d1e380380610d1e83398101604081905261002e9161005c565b6001600160a01b039182166080521660a052610094565b6001600160a01b0381168114610059575f5ffd5b50565b5f5f6040838503121561006d575f5ffd5b825161007881610045565b602084015190925061008981610045565b809150509250929050565b60805160a051610c486100d65f395f8181605301528181610155015261028901525f818160a3015281816101c10152818161032801526104620152610c485ff3fe608060405234801561000f575f5ffd5b506004361061004a575f3560e01c806316f0115b1461004e57806325e2d6251461009e57806350634c0e146100c55780637f814f35146100da575b5f5ffd5b6100757f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200160405180910390f35b6100757f000000000000000000000000000000000000000000000000000000000000000081565b6100d86100d33660046109ce565b6100ed565b005b6100d86100e8366004610a90565b610117565b5f818060200190518101906101029190610b14565b905061011085858584610117565b5050505050565b61013973ffffffffffffffffffffffffffffffffffffffff85163330866104bf565b61017a73ffffffffffffffffffffffffffffffffffffffff85167f000000000000000000000000000000000000000000000000000000000000000085610583565b6040517f70a0823100000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff83811660048301525f917f0000000000000000000000000000000000000000000000000000000000000000909116906370a0823190602401602060405180830381865afa158015610208573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061022c9190610b38565b6040517f617ba03700000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff87811660048301526024820187905285811660448301525f60648301529192507f00000000000000000000000000000000000000000000000000000000000000009091169063617ba037906084015f604051808303815f87803b1580156102cc575f5ffd5b505af11580156102de573d5f5f3e3d5ffd5b50506040517f70a0823100000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff86811660048301525f93507f00000000000000000000000000000000000000000000000000000000000000001691506370a0823190602401602060405180830381865afa15801561036e573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103929190610b38565b90508181116103e85760405162461bcd60e51b815260206004820152601c60248201527f496e73756666696369656e7420737570706c792070726f76696465640000000060448201526064015b60405180910390fd5b5f6103f38383610b7c565b84519091508110156104475760405162461bcd60e51b815260206004820152601a60248201527f496e73756666696369656e74206f757470757420616d6f756e7400000000000060448201526064016103df565b6040805173ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000168152602081018390527f0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d910160405180910390a150505050505050565b60405173ffffffffffffffffffffffffffffffffffffffff8085166024830152831660448201526064810182905261057d9085907f23b872dd00000000000000000000000000000000000000000000000000000000906084015b60408051601f198184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff000000000000000000000000000000000000000000000000000000009093169290921790915261067e565b50505050565b6040517fdd62ed3e00000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff83811660248301525f91839186169063dd62ed3e90604401602060405180830381865afa1580156105f7573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061061b9190610b38565b6106259190610b95565b60405173ffffffffffffffffffffffffffffffffffffffff851660248201526044810182905290915061057d9085907f095ea7b30000000000000000000000000000000000000000000000000000000090606401610519565b5f6106df826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166107749092919063ffffffff16565b80519091501561076f57808060200190518101906106fd9190610ba8565b61076f5760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f7420737563636565640000000000000000000000000000000000000000000060648201526084016103df565b505050565b606061078284845f8561078c565b90505b9392505050565b6060824710156108045760405162461bcd60e51b815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c000000000000000000000000000000000000000000000000000060648201526084016103df565b73ffffffffffffffffffffffffffffffffffffffff85163b6108685760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e747261637400000060448201526064016103df565b5f5f8673ffffffffffffffffffffffffffffffffffffffff1685876040516108909190610bc7565b5f6040518083038185875af1925050503d805f81146108ca576040519150601f19603f3d011682016040523d82523d5f602084013e6108cf565b606091505b50915091506108df8282866108ea565b979650505050505050565b606083156108f9575081610785565b8251156109095782518084602001fd5b8160405162461bcd60e51b81526004016103df9190610bdd565b73ffffffffffffffffffffffffffffffffffffffff81168114610944575f5ffd5b50565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b6040516020810167ffffffffffffffff8111828210171561099757610997610947565b60405290565b604051601f8201601f1916810167ffffffffffffffff811182821017156109c6576109c6610947565b604052919050565b5f5f5f5f608085870312156109e1575f5ffd5b84356109ec81610923565b9350602085013592506040850135610a0381610923565b9150606085013567ffffffffffffffff811115610a1e575f5ffd5b8501601f81018713610a2e575f5ffd5b803567ffffffffffffffff811115610a4857610a48610947565b610a5b6020601f19601f8401160161099d565b818152886020838501011115610a6f575f5ffd5b816020840160208301375f6020838301015280935050505092959194509250565b5f5f5f5f8486036080811215610aa4575f5ffd5b8535610aaf81610923565b9450602086013593506040860135610ac681610923565b925060207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa082011215610af7575f5ffd5b50610b00610974565b606095909501358552509194909350909190565b5f6020828403128015610b25575f5ffd5b50610b2e610974565b9151825250919050565b5f60208284031215610b48575f5ffd5b5051919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b81810381811115610b8f57610b8f610b4f565b92915050565b80820180821115610b8f57610b8f610b4f565b5f60208284031215610bb8575f5ffd5b81518015158114610785575f5ffd5b5f82518060208501845e5f920191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f8301168401019150509291505056fea264697066735822122082cf598164946b8f719c4d82ef5ef60e3dda57bec73de3e887b66e790bf7577164736f6c634300081c0033 - /// ``` - #[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\r\x1E8\x03\x80a\r\x1E\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CHa\0\xD6_9_\x81\x81`S\x01R\x81\x81a\x01U\x01Ra\x02\x89\x01R_\x81\x81`\xA3\x01R\x81\x81a\x01\xC1\x01R\x81\x81a\x03(\x01Ra\x04b\x01Ra\x0CH_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x16\xF0\x11[\x14a\0NW\x80c%\xE2\xD6%\x14a\0\x9EW\x80cPcL\x0E\x14a\0\xC5W\x80c\x7F\x81O5\x14a\0\xDAW[__\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\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[a\0\xD8a\0\xD36`\x04a\t\xCEV[a\0\xEDV[\0[a\0\xD8a\0\xE86`\x04a\n\x90V[a\x01\x17V[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x14V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xBFV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x83V[`@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\x83\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B8V[`@Q\x7Fa{\xA07\0\0\0\0\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`$\x82\x01\x87\x90R\x85\x81\x16`D\x83\x01R_`d\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\x90ca{\xA07\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\xCCW__\xFD[PZ\xF1\x15\x80\x15a\x02\xDEW=__>=_\xFD[PP`@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\x86\x81\x16`\x04\x83\x01R_\x93P\x7F\0\0\0\0\0\0\0\0\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\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03nW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x92\x91\x90a\x0B8V[\x90P\x81\x81\x11a\x03\xE8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x03\xF3\x83\x83a\x0B|V[\x84Q\x90\x91P\x81\x10\x15a\x04GW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xDFV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05}\x90\x85\x90\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\x90`\x84\x01[`@\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~V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1B\x91\x90a\x0B8V[a\x06%\x91\x90a\x0B\x95V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05}\x90\x85\x90\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\x90`d\x01a\x05\x19V[_a\x06\xDF\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\x07t\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07oW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFD\x91\x90a\x0B\xA8V[a\x07oW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[PPPV[``a\x07\x82\x84\x84_\x85a\x07\x8CV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\x04W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08hW`@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\x03\xDFV[__\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\x08\x90\x91\x90a\x0B\xC7V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xCAW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xCFV[``\x91P[P\x91P\x91Pa\x08\xDF\x82\x82\x86a\x08\xEAV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xF9WP\x81a\x07\x85V[\x82Q\x15a\t\tW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xDF\x91\x90a\x0B\xDDV[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\tDW__\xFD[PV[\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\x97Wa\t\x97a\tGV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC6Wa\t\xC6a\tGV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE1W__\xFD[\x845a\t\xEC\x81a\t#V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x03\x81a\t#V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x1EW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n.W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nHWa\nHa\tGV[a\n[` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9DV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\noW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA4W__\xFD[\x855a\n\xAF\x81a\t#V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC6\x81a\t#V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF7W__\xFD[Pa\x0B\0a\ttV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B%W__\xFD[Pa\x0B.a\ttV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BHW__\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[\x81\x81\x03\x81\x81\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[_` \x82\x84\x03\x12\x15a\x0B\xB8W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x85W__\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\xFE\xA2dipfsX\"\x12 \x82\xCFY\x81d\x94k\x8Fq\x9CM\x82\xEF^\xF6\x0E=\xDAW\xBE\xC7=\xE3\xE8\x87\xB6ny\x0B\xF7WqdsolcC\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\x16\xF0\x11[\x14a\0NW\x80c%\xE2\xD6%\x14a\0\x9EW\x80cPcL\x0E\x14a\0\xC5W\x80c\x7F\x81O5\x14a\0\xDAW[__\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\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[a\0\xD8a\0\xD36`\x04a\t\xCEV[a\0\xEDV[\0[a\0\xD8a\0\xE86`\x04a\n\x90V[a\x01\x17V[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x14V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xBFV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x83V[`@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\x83\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B8V[`@Q\x7Fa{\xA07\0\0\0\0\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`$\x82\x01\x87\x90R\x85\x81\x16`D\x83\x01R_`d\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\x90ca{\xA07\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\xCCW__\xFD[PZ\xF1\x15\x80\x15a\x02\xDEW=__>=_\xFD[PP`@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\x86\x81\x16`\x04\x83\x01R_\x93P\x7F\0\0\0\0\0\0\0\0\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\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03nW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x92\x91\x90a\x0B8V[\x90P\x81\x81\x11a\x03\xE8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x03\xF3\x83\x83a\x0B|V[\x84Q\x90\x91P\x81\x10\x15a\x04GW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xDFV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05}\x90\x85\x90\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\x90`\x84\x01[`@\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~V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1B\x91\x90a\x0B8V[a\x06%\x91\x90a\x0B\x95V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05}\x90\x85\x90\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\x90`d\x01a\x05\x19V[_a\x06\xDF\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\x07t\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07oW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFD\x91\x90a\x0B\xA8V[a\x07oW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[PPPV[``a\x07\x82\x84\x84_\x85a\x07\x8CV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\x04W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08hW`@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\x03\xDFV[__\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\x08\x90\x91\x90a\x0B\xC7V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xCAW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xCFV[``\x91P[P\x91P\x91Pa\x08\xDF\x82\x82\x86a\x08\xEAV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xF9WP\x81a\x07\x85V[\x82Q\x15a\t\tW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xDF\x91\x90a\x0B\xDDV[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\tDW__\xFD[PV[\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\x97Wa\t\x97a\tGV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC6Wa\t\xC6a\tGV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE1W__\xFD[\x845a\t\xEC\x81a\t#V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x03\x81a\t#V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x1EW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n.W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nHWa\nHa\tGV[a\n[` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9DV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\noW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA4W__\xFD[\x855a\n\xAF\x81a\t#V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC6\x81a\t#V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF7W__\xFD[Pa\x0B\0a\ttV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B%W__\xFD[Pa\x0B.a\ttV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BHW__\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[\x81\x81\x03\x81\x81\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[_` \x82\x84\x03\x12\x15a\x0B\xB8W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x85W__\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\xFE\xA2dipfsX\"\x12 \x82\xCFY\x81d\x94k\x8Fq\x9CM\x82\xEF^\xF6\x0E=\xDAW\xBE\xC7=\xE3\xE8\x87\xB6ny\x0B\xF7WqdsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct StrategySlippageArgs { uint256 amountOutMin; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct StrategySlippageArgs { - #[allow(missing_docs)] - pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: StrategySlippageArgs) -> Self { - (value.amountOutMin,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for StrategySlippageArgs { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { amountOutMin: tuple.0 } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for StrategySlippageArgs { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for StrategySlippageArgs { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for StrategySlippageArgs { - const NAME: &'static str = "StrategySlippageArgs"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "StrategySlippageArgs(uint256 amountOutMin)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) - .0 - .to_vec() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for StrategySlippageArgs { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.amountOutMin, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.amountOutMin, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. -```solidity -event TokenOutput(address tokenReceived, uint256 amountOut); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct TokenOutput { - #[allow(missing_docs)] - pub tokenReceived: alloy::sol_types::private::Address, - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for TokenOutput { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - tokenReceived: data.0, - amountOut: data.1, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.tokenReceived, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountOut), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 TokenOutput { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&TokenOutput> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - /**Constructor`. -```solidity -constructor(address _avBep20, address _pool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct constructorCall { - #[allow(missing_docs)] - pub _avBep20: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub _pool: alloy::sol_types::private::Address, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value._avBep20, value._pool) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - _avBep20: tuple.0, - _pool: 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> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._avBep20, - ), - ::tokenize( - &self._pool, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `avBep20()` and selector `0x25e2d625`. -```solidity -function avBep20() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct avBep20Call; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`avBep20()`](avBep20Call) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct avBep20Return { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: avBep20Call) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for avBep20Call { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: avBep20Return) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for avBep20Return { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for avBep20Call { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "avBep20()"; - const SELECTOR: [u8; 4] = [37u8, 226u8, 214u8, 37u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: avBep20Return = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: avBep20Return = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. -```solidity -function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub message: alloy::sol_types::private::Bytes, - } - ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ); - #[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, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.message) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - message: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageCall { - 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, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; - const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.message, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. -```solidity -function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub args: ::RustType, - } - ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::primitives::aliases::U256, - alloy::sol_types::private::Address, - ::RustType, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.args) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - args: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageWithSlippageArgsReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageWithSlippageArgsReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; - const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.args, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `pool()` and selector `0x16f0115b`. -```solidity -function pool() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct poolCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`pool()`](poolCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct poolReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: poolCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for poolCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: poolReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for poolReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for poolCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "pool()"; - const SELECTOR: [u8; 4] = [22u8, 240u8, 17u8, 91u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: poolReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: poolReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`AvalonLendingStrategy`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum AvalonLendingStrategyCalls { - #[allow(missing_docs)] - avBep20(avBep20Call), - #[allow(missing_docs)] - handleGatewayMessage(handleGatewayMessageCall), - #[allow(missing_docs)] - handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), - #[allow(missing_docs)] - pool(poolCall), - } - #[automatically_derived] - impl AvalonLendingStrategyCalls { - /// 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, 240u8, 17u8, 91u8], - [37u8, 226u8, 214u8, 37u8], - [80u8, 99u8, 76u8, 14u8], - [127u8, 129u8, 79u8, 53u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for AvalonLendingStrategyCalls { - const NAME: &'static str = "AvalonLendingStrategyCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 4usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::avBep20(_) => ::SELECTOR, - Self::handleGatewayMessage(_) => { - ::SELECTOR - } - Self::handleGatewayMessageWithSlippageArgs(_) => { - ::SELECTOR - } - Self::pool(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn pool( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(AvalonLendingStrategyCalls::pool) - } - pool - }, - { - fn avBep20( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(AvalonLendingStrategyCalls::avBep20) - } - avBep20 - }, - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonLendingStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - AvalonLendingStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn pool( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonLendingStrategyCalls::pool) - } - pool - }, - { - fn avBep20( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonLendingStrategyCalls::avBep20) - } - avBep20 - }, - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonLendingStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - AvalonLendingStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::avBep20(inner) => { - ::abi_encoded_size(inner) - } - Self::handleGatewayMessage(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::pool(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::avBep20(inner) => { - ::abi_encode_raw(inner, out) - } - Self::handleGatewayMessage(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::pool(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - ///Container for all the [`AvalonLendingStrategy`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum AvalonLendingStrategyEvents { - #[allow(missing_docs)] - TokenOutput(TokenOutput), - } - #[automatically_derived] - impl AvalonLendingStrategyEvents { - /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for AvalonLendingStrategyEvents { - const NAME: &'static str = "AvalonLendingStrategyEvents"; - const COUNT: usize = 1usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::TokenOutput) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 AvalonLendingStrategyEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`AvalonLendingStrategy`](self) contract instance. - -See the [wrapper's documentation](`AvalonLendingStrategyInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> AvalonLendingStrategyInstance { - AvalonLendingStrategyInstance::::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: alloy_contract::private::Network, - >( - provider: P, - _avBep20: alloy::sol_types::private::Address, - _pool: alloy::sol_types::private::Address, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - AvalonLendingStrategyInstance::::deploy(provider, _avBep20, _pool) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - _avBep20: alloy::sol_types::private::Address, - _pool: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - AvalonLendingStrategyInstance::::deploy_builder(provider, _avBep20, _pool) - } - /**A [`AvalonLendingStrategy`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`AvalonLendingStrategy`](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 AvalonLendingStrategyInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for AvalonLendingStrategyInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("AvalonLendingStrategyInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > AvalonLendingStrategyInstance { - /**Creates a new wrapper around an on-chain [`AvalonLendingStrategy`](self) contract instance. - -See the [wrapper's documentation](`AvalonLendingStrategyInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - _avBep20: alloy::sol_types::private::Address, - _pool: alloy::sol_types::private::Address, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder(provider, _avBep20, _pool); - 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, - _avBep20: alloy::sol_types::private::Address, - _pool: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { _avBep20, _pool }, - )[..], - ] - .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 AvalonLendingStrategyInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> AvalonLendingStrategyInstance { - AvalonLendingStrategyInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > AvalonLendingStrategyInstance { - /// 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( - &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 [`avBep20`] function. - pub fn avBep20(&self) -> alloy_contract::SolCallBuilder<&P, avBep20Call, N> { - self.call_builder(&avBep20Call) - } - ///Creates a new call builder for the [`handleGatewayMessage`] function. - pub fn handleGatewayMessage( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - message: alloy::sol_types::private::Bytes, - ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { - self.call_builder( - &handleGatewayMessageCall { - tokenSent, - amountIn, - recipient, - message, - }, - ) - } - ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. - pub fn handleGatewayMessageWithSlippageArgs( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - args: ::RustType, - ) -> alloy_contract::SolCallBuilder< - &P, - handleGatewayMessageWithSlippageArgsCall, - N, - > { - self.call_builder( - &handleGatewayMessageWithSlippageArgsCall { - tokenSent, - amountIn, - recipient, - args, - }, - ) - } - ///Creates a new call builder for the [`pool`] function. - pub fn pool(&self) -> alloy_contract::SolCallBuilder<&P, poolCall, N> { - self.call_builder(&poolCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > AvalonLendingStrategyInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`TokenOutput`] event. - pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/avalon_lst_strategy.rs b/crates/bindings/src/avalon_lst_strategy.rs deleted file mode 100644 index 31688a4bf..000000000 --- a/crates/bindings/src/avalon_lst_strategy.rs +++ /dev/null @@ -1,1812 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface AvalonLstStrategy { - struct StrategySlippageArgs { - uint256 amountOutMin; - } - - event TokenOutput(address tokenReceived, uint256 amountOut); - - constructor(address _solvLSTStrategy, address _avalonLendingStrategy); - - function avalonLendingStrategy() external view returns (address); - function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; - function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; - function solvLSTStrategy() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "_solvLSTStrategy", - "type": "address", - "internalType": "contract SolvLSTStrategy" - }, - { - "name": "_avalonLendingStrategy", - "type": "address", - "internalType": "contract AvalonLendingStrategy" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "avalonLendingStrategy", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract AvalonLendingStrategy" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "handleGatewayMessage", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "message", - "type": "bytes", - "internalType": "bytes" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessageWithSlippageArgs", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "args", - "type": "tuple", - "internalType": "struct StrategySlippageArgs", - "components": [ - { - "name": "amountOutMin", - "type": "uint256", - "internalType": "uint256" - } - ] - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "solvLSTStrategy", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract SolvLSTStrategy" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "TokenOutput", - "inputs": [ - { - "name": "tokenReceived", - "type": "address", - "indexed": false, - "internalType": "address" - }, - { - "name": "amountOut", - "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 AvalonLstStrategy { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x60c060405234801561000f575f5ffd5b50604051610d20380380610d2083398101604081905261002e9161005c565b6001600160a01b039182166080521660a052610094565b6001600160a01b0381168114610059575f5ffd5b50565b5f5f6040838503121561006d575f5ffd5b825161007881610045565b602084015190925061008981610045565b809150509250929050565b60805160a051610c4a6100d65f395f818160530152818161037501526103f501525f818160cb01528181610155015281816101df015261023b0152610c4a5ff3fe608060405234801561000f575f5ffd5b506004361061004a575f3560e01c806346226c311461004e57806350634c0e1461009e5780637f814f35146100b3578063f2234cf9146100c6575b5f5ffd5b6100757f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200160405180910390f35b6100b16100ac3660046109d0565b6100ed565b005b6100b16100c1366004610a92565b610117565b6100757f000000000000000000000000000000000000000000000000000000000000000081565b5f818060200190518101906101029190610b16565b905061011085858584610117565b5050505050565b61013973ffffffffffffffffffffffffffffffffffffffff8516333086610454565b61017a73ffffffffffffffffffffffffffffffffffffffff85167f000000000000000000000000000000000000000000000000000000000000000085610518565b604080516020810182525f815290517f7f814f3500000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff868116600483015260248201869052306044830152915160648201527f000000000000000000000000000000000000000000000000000000000000000090911690637f814f35906084015f604051808303815f87803b158015610222575f5ffd5b505af1158015610234573d5f5f3e3d5ffd5b505050505f7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663ad747de66040518163ffffffff1660e01b8152600401602060405180830381865afa1580156102a2573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906102c69190610b3a565b6040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201529091505f9073ffffffffffffffffffffffffffffffffffffffff8316906370a0823190602401602060405180830381865afa158015610333573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103579190610b55565b905061039a73ffffffffffffffffffffffffffffffffffffffff83167f000000000000000000000000000000000000000000000000000000000000000083610518565b6040517f7f814f3500000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8381166004830152602482018390528581166044830152845160648301527f00000000000000000000000000000000000000000000000000000000000000001690637f814f35906084015f604051808303815f87803b158015610436575f5ffd5b505af1158015610448573d5f5f3e3d5ffd5b50505050505050505050565b60405173ffffffffffffffffffffffffffffffffffffffff808516602483015283166044820152606481018290526105129085907f23b872dd00000000000000000000000000000000000000000000000000000000906084015b60408051601f198184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff0000000000000000000000000000000000000000000000000000000090931692909217909152610613565b50505050565b6040517fdd62ed3e00000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff83811660248301525f91839186169063dd62ed3e90604401602060405180830381865afa15801561058c573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906105b09190610b55565b6105ba9190610b6c565b60405173ffffffffffffffffffffffffffffffffffffffff85166024820152604481018290529091506105129085907f095ea7b300000000000000000000000000000000000000000000000000000000906064016104ae565b5f610674826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166107289092919063ffffffff16565b80519091501561072357808060200190518101906106929190610baa565b610723576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f7420737563636565640000000000000000000000000000000000000000000060648201526084015b60405180910390fd5b505050565b606061073684845f85610740565b90505b9392505050565b6060824710156107d2576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c0000000000000000000000000000000000000000000000000000606482015260840161071a565b73ffffffffffffffffffffffffffffffffffffffff85163b610850576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015260640161071a565b5f5f8673ffffffffffffffffffffffffffffffffffffffff1685876040516108789190610bc9565b5f6040518083038185875af1925050503d805f81146108b2576040519150601f19603f3d011682016040523d82523d5f602084013e6108b7565b606091505b50915091506108c78282866108d2565b979650505050505050565b606083156108e1575081610739565b8251156108f15782518084602001fd5b816040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161071a9190610bdf565b73ffffffffffffffffffffffffffffffffffffffff81168114610946575f5ffd5b50565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b6040516020810167ffffffffffffffff8111828210171561099957610999610949565b60405290565b604051601f8201601f1916810167ffffffffffffffff811182821017156109c8576109c8610949565b604052919050565b5f5f5f5f608085870312156109e3575f5ffd5b84356109ee81610925565b9350602085013592506040850135610a0581610925565b9150606085013567ffffffffffffffff811115610a20575f5ffd5b8501601f81018713610a30575f5ffd5b803567ffffffffffffffff811115610a4a57610a4a610949565b610a5d6020601f19601f8401160161099f565b818152886020838501011115610a71575f5ffd5b816020840160208301375f6020838301015280935050505092959194509250565b5f5f5f5f8486036080811215610aa6575f5ffd5b8535610ab181610925565b9450602086013593506040860135610ac881610925565b925060207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa082011215610af9575f5ffd5b50610b02610976565b606095909501358552509194909350909190565b5f6020828403128015610b27575f5ffd5b50610b30610976565b9151825250919050565b5f60208284031215610b4a575f5ffd5b815161073981610925565b5f60208284031215610b65575f5ffd5b5051919050565b80820180821115610ba4577f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b92915050565b5f60208284031215610bba575f5ffd5b81518015158114610739575f5ffd5b5f82518060208501845e5f920191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f8301168401019150509291505056fea26469706673582212200f900405043b43af2c7f752cfe8ca7ffd733511a053e1a3e8ad4b3001398002464736f6c634300081c0033 - /// ``` - #[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\r 8\x03\x80a\r \x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CJa\0\xD6_9_\x81\x81`S\x01R\x81\x81a\x03u\x01Ra\x03\xF5\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0CJ_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cF\"l1\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xF2#L\xF9\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\t\xD0V[a\0\xEDV[\0[a\0\xB1a\0\xC16`\x04a\n\x92V[a\x01\x17V[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[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 \x0F\x90\x04\x05\x04;C\xAF,\x7Fu,\xFE\x8C\xA7\xFF\xD73Q\x1A\x05>\x1A>\x8A\xD4\xB3\0\x13\x98\0$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\x80cF\"l1\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xF2#L\xF9\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\t\xD0V[a\0\xEDV[\0[a\0\xB1a\0\xC16`\x04a\n\x92V[a\x01\x17V[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[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 \x0F\x90\x04\x05\x04;C\xAF,\x7Fu,\xFE\x8C\xA7\xFF\xD73Q\x1A\x05>\x1A>\x8A\xD4\xB3\0\x13\x98\0$dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct StrategySlippageArgs { uint256 amountOutMin; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct StrategySlippageArgs { - #[allow(missing_docs)] - pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: StrategySlippageArgs) -> Self { - (value.amountOutMin,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for StrategySlippageArgs { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { amountOutMin: tuple.0 } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for StrategySlippageArgs { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for StrategySlippageArgs { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for StrategySlippageArgs { - const NAME: &'static str = "StrategySlippageArgs"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "StrategySlippageArgs(uint256 amountOutMin)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) - .0 - .to_vec() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for StrategySlippageArgs { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.amountOutMin, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.amountOutMin, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. -```solidity -event TokenOutput(address tokenReceived, uint256 amountOut); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct TokenOutput { - #[allow(missing_docs)] - pub tokenReceived: alloy::sol_types::private::Address, - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for TokenOutput { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - tokenReceived: data.0, - amountOut: data.1, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.tokenReceived, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountOut), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 TokenOutput { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&TokenOutput> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - /**Constructor`. -```solidity -constructor(address _solvLSTStrategy, address _avalonLendingStrategy); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct constructorCall { - #[allow(missing_docs)] - pub _solvLSTStrategy: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub _avalonLendingStrategy: alloy::sol_types::private::Address, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value._solvLSTStrategy, value._avalonLendingStrategy) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - _solvLSTStrategy: tuple.0, - _avalonLendingStrategy: 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> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._solvLSTStrategy, - ), - ::tokenize( - &self._avalonLendingStrategy, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `avalonLendingStrategy()` and selector `0x46226c31`. -```solidity -function avalonLendingStrategy() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct avalonLendingStrategyCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`avalonLendingStrategy()`](avalonLendingStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct avalonLendingStrategyReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: avalonLendingStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for avalonLendingStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: avalonLendingStrategyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for avalonLendingStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for avalonLendingStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "avalonLendingStrategy()"; - const SELECTOR: [u8; 4] = [70u8, 34u8, 108u8, 49u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: avalonLendingStrategyReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: avalonLendingStrategyReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. -```solidity -function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub message: alloy::sol_types::private::Bytes, - } - ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ); - #[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, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.message) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - message: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageCall { - 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, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; - const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.message, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. -```solidity -function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub args: ::RustType, - } - ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::primitives::aliases::U256, - alloy::sol_types::private::Address, - ::RustType, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.args) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - args: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageWithSlippageArgsReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageWithSlippageArgsReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; - const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.args, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `solvLSTStrategy()` and selector `0xf2234cf9`. -```solidity -function solvLSTStrategy() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct solvLSTStrategyCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`solvLSTStrategy()`](solvLSTStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct solvLSTStrategyReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: solvLSTStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for solvLSTStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: solvLSTStrategyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for solvLSTStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for solvLSTStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "solvLSTStrategy()"; - const SELECTOR: [u8; 4] = [242u8, 35u8, 76u8, 249u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: solvLSTStrategyReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: solvLSTStrategyReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`AvalonLstStrategy`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum AvalonLstStrategyCalls { - #[allow(missing_docs)] - avalonLendingStrategy(avalonLendingStrategyCall), - #[allow(missing_docs)] - handleGatewayMessage(handleGatewayMessageCall), - #[allow(missing_docs)] - handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), - #[allow(missing_docs)] - solvLSTStrategy(solvLSTStrategyCall), - } - #[automatically_derived] - impl AvalonLstStrategyCalls { - /// 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]] = &[ - [70u8, 34u8, 108u8, 49u8], - [80u8, 99u8, 76u8, 14u8], - [127u8, 129u8, 79u8, 53u8], - [242u8, 35u8, 76u8, 249u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for AvalonLstStrategyCalls { - const NAME: &'static str = "AvalonLstStrategyCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 4usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::avalonLendingStrategy(_) => { - ::SELECTOR - } - Self::handleGatewayMessage(_) => { - ::SELECTOR - } - Self::handleGatewayMessageWithSlippageArgs(_) => { - ::SELECTOR - } - Self::solvLSTStrategy(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn avalonLendingStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonLstStrategyCalls::avalonLendingStrategy) - } - avalonLendingStrategy - }, - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonLstStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - AvalonLstStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - { - fn solvLSTStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonLstStrategyCalls::solvLSTStrategy) - } - solvLSTStrategy - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn avalonLendingStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonLstStrategyCalls::avalonLendingStrategy) - } - avalonLendingStrategy - }, - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonLstStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - AvalonLstStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - { - fn solvLSTStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonLstStrategyCalls::solvLSTStrategy) - } - solvLSTStrategy - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::avalonLendingStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::handleGatewayMessage(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::solvLSTStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::avalonLendingStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::handleGatewayMessage(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::solvLSTStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`AvalonLstStrategy`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum AvalonLstStrategyEvents { - #[allow(missing_docs)] - TokenOutput(TokenOutput), - } - #[automatically_derived] - impl AvalonLstStrategyEvents { - /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for AvalonLstStrategyEvents { - const NAME: &'static str = "AvalonLstStrategyEvents"; - const COUNT: usize = 1usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::TokenOutput) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 AvalonLstStrategyEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`AvalonLstStrategy`](self) contract instance. - -See the [wrapper's documentation](`AvalonLstStrategyInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> AvalonLstStrategyInstance { - AvalonLstStrategyInstance::::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: alloy_contract::private::Network, - >( - provider: P, - _solvLSTStrategy: alloy::sol_types::private::Address, - _avalonLendingStrategy: alloy::sol_types::private::Address, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - AvalonLstStrategyInstance::< - P, - N, - >::deploy(provider, _solvLSTStrategy, _avalonLendingStrategy) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - _solvLSTStrategy: alloy::sol_types::private::Address, - _avalonLendingStrategy: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - AvalonLstStrategyInstance::< - P, - N, - >::deploy_builder(provider, _solvLSTStrategy, _avalonLendingStrategy) - } - /**A [`AvalonLstStrategy`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`AvalonLstStrategy`](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 AvalonLstStrategyInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for AvalonLstStrategyInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("AvalonLstStrategyInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > AvalonLstStrategyInstance { - /**Creates a new wrapper around an on-chain [`AvalonLstStrategy`](self) contract instance. - -See the [wrapper's documentation](`AvalonLstStrategyInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - _solvLSTStrategy: alloy::sol_types::private::Address, - _avalonLendingStrategy: alloy::sol_types::private::Address, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder( - provider, - _solvLSTStrategy, - _avalonLendingStrategy, - ); - 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, - _solvLSTStrategy: alloy::sol_types::private::Address, - _avalonLendingStrategy: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { - _solvLSTStrategy, - _avalonLendingStrategy, - }, - )[..], - ] - .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 AvalonLstStrategyInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> AvalonLstStrategyInstance { - AvalonLstStrategyInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > AvalonLstStrategyInstance { - /// 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( - &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 [`avalonLendingStrategy`] function. - pub fn avalonLendingStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, avalonLendingStrategyCall, N> { - self.call_builder(&avalonLendingStrategyCall) - } - ///Creates a new call builder for the [`handleGatewayMessage`] function. - pub fn handleGatewayMessage( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - message: alloy::sol_types::private::Bytes, - ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { - self.call_builder( - &handleGatewayMessageCall { - tokenSent, - amountIn, - recipient, - message, - }, - ) - } - ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. - pub fn handleGatewayMessageWithSlippageArgs( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - args: ::RustType, - ) -> alloy_contract::SolCallBuilder< - &P, - handleGatewayMessageWithSlippageArgsCall, - N, - > { - self.call_builder( - &handleGatewayMessageWithSlippageArgsCall { - tokenSent, - amountIn, - recipient, - args, - }, - ) - } - ///Creates a new call builder for the [`solvLSTStrategy`] function. - pub fn solvLSTStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, solvLSTStrategyCall, N> { - self.call_builder(&solvLSTStrategyCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > AvalonLstStrategyInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`TokenOutput`] event. - pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/avalon_tbtc_lending_strategy_forked.rs b/crates/bindings/src/avalon_tbtc_lending_strategy_forked.rs deleted file mode 100644 index c06be1a12..000000000 --- a/crates/bindings/src/avalon_tbtc_lending_strategy_forked.rs +++ /dev/null @@ -1,8013 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface AvalonTBTCLendingStrategyForked { - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function setUp() external; - function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function testAvalonTBTCStrategy() external; - function token() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "setUp", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "simulateForkAndTransfer", - "inputs": [ - { - "name": "forkAtBlock", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "sender", - "type": "address", - "internalType": "address" - }, - { - "name": "receiver", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testAvalonTBTCStrategy", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "token", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IERC20" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 AvalonTBTCLendingStrategyForked { - use super::*; - use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15`+W__\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16t\xBB\xA2\xEF\x94]R^<#\x14a\x01=_\xFD[P`@Q\x7F\xCAf\x9F\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\x81Rs\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05\x94W__\xFD[PZ\xF1\x15\x80\x15a\x05\xA6W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x06 W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06D\x91\x90a\x17\x8CV[Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x06\x91W__\xFD[PZ\xF1\x15\x80\x15a\x06\xA3W=__>=_\xFD[PP`@Q\x7F\xCAf\x9F\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\x81Rs\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x92Pc\xCAf\x9F\xA7\x91P`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07\x1DW__\xFD[PZ\xF1\x15\x80\x15a\x07/W=__>=_\xFD[PP`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x84\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x84\x16\x92Pc\x7F\x81O5\x91P`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07\xBDW__\xFD[PZ\xF1\x15\x80\x15a\x07\xCFW=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\x1FW__\xFD[PZ\xF1\x15\x80\x15a\x081W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\x08\xC7\x93Pa\x01\0\x90\x91\x04`\x01`\x01`\xA0\x1B\x03\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x9DW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\xC1\x91\x90a\x17\xB2V[_a\x13GV[`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t*W__\xFD[PZ\xF1\x15\x80\x15a\t=_\xFD[PP`\x1FT`@Q\x7Fi2\x8D\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\x81Ra\x01\0\x90\x91\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01R`\x01`D\x83\x01R\x85\x16\x92Pci2\x8D\xEC\x91P`d\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\t\xBCW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\xE0\x91\x90a\x17\xB2V[Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\n-W__\xFD[PZ\xF1\x15\x80\x15a\n?W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\n\xDD\x93Pa\x01\0\x90\x91\x04`\x01`\x01`\xA0\x1B\x03\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\n\xABW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xCF\x91\x90a\x17\xB2V[g\r\xE0\xB6\xB3\xA7d\0\0a\x13GV[PPPV[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x03\xE7W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x0B5\x90a\x17;V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0Ba\x90a\x17;V[\x80\x15a\x0B\xACW\x80`\x1F\x10a\x0B\x83Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\xACV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\x8FW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x0CCW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0B\xF0W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0B\x05V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x03\xE7W\x83\x82\x90_R` _ \x01\x80Ta\x0C\x9B\x90a\x17;V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C\xC7\x90a\x17;V[\x80\x15a\r\x12W\x80`\x1F\x10a\x0C\xE9Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\r\x12V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0C\xF5W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0C~V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x03\xE7W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0E\x04W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\xB1W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\rIV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x03\xE7W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0E\xFAW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0E\xA7W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0E?V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x03\xE7W\x83\x82\x90_R` _ \x01\x80Ta\x0FR\x90a\x17;V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F~\x90a\x17;V[\x80\x15a\x0F\xC9W\x80`\x1F\x10a\x0F\xA0Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F\xC9V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\xACW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0F5V[`\x08T_\x90`\xFF\x16\x15a\x0F\xF4WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\x82W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\xA6\x91\x90a\x17\xB2V[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xAAW` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\x8CWPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\xA6W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x11\xCD\x91\x90\x81\x01\x90a\x17\xF6V[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x11\xEB\x92\x91\x90a\x18\xAAV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x12\x07W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12+\x91\x90a\x17\xB2V[P`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12\x97W__\xFD[PZ\xF1\x15\x80\x15a\x12\xA9W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x13\x1CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13@\x91\x90a\x17\x8CV[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x13\xB0W__\xFD[PZ\xFA\x15\x80\x15a\x13\xC2W=__>=_\xFD[PPPPPPV[a\r\x1E\x80a\x18\xCC\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x14\x17W\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x13\xF0V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15+W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`\x01`\x01`\xA0\x1B\x03\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x15\x11W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x14\xFB\x84\x86Qa\x14\"V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x14\xC1V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x14vV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x15\x89W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x15IV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15+W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x15\xDF`@\x88\x01\x82a\x14\"V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x15\xFA\x81\x83a\x157V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\xB9V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15+W`?\x19\x87\x86\x03\x01\x84Ra\x16S\x85\x83Qa\x14\"V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x167V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15+W`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x16\xC9`@\x87\x01\x82a\x157V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16\x8EV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x16\xF5W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x17\rW__\xFD[\x845\x93Pa\x17\x1D` \x86\x01a\x16\xDFV[\x92Pa\x17+`@\x86\x01a\x16\xDFV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x17OW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x17\x86W\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17\x9CW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x17\xABW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x17\xC2W__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x18\x06W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\x1CW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x18,W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18FWa\x18Fa\x17\xC9V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x18vWa\x18va\x17\xC9V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x18\x8DW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x18\xBC`@\x83\x01\x85a\x14\"V[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\x1E8\x03\x80a\r\x1E\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CHa\0\xD6_9_\x81\x81`S\x01R\x81\x81a\x01U\x01Ra\x02\x89\x01R_\x81\x81`\xA3\x01R\x81\x81a\x01\xC1\x01R\x81\x81a\x03(\x01Ra\x04b\x01Ra\x0CH_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x16\xF0\x11[\x14a\0NW\x80c%\xE2\xD6%\x14a\0\x9EW\x80cPcL\x0E\x14a\0\xC5W\x80c\x7F\x81O5\x14a\0\xDAW[__\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\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[a\0\xD8a\0\xD36`\x04a\t\xCEV[a\0\xEDV[\0[a\0\xD8a\0\xE86`\x04a\n\x90V[a\x01\x17V[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x14V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xBFV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x83V[`@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\x83\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B8V[`@Q\x7Fa{\xA07\0\0\0\0\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`$\x82\x01\x87\x90R\x85\x81\x16`D\x83\x01R_`d\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\x90ca{\xA07\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\xCCW__\xFD[PZ\xF1\x15\x80\x15a\x02\xDEW=__>=_\xFD[PP`@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\x86\x81\x16`\x04\x83\x01R_\x93P\x7F\0\0\0\0\0\0\0\0\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\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03nW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x92\x91\x90a\x0B8V[\x90P\x81\x81\x11a\x03\xE8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x03\xF3\x83\x83a\x0B|V[\x84Q\x90\x91P\x81\x10\x15a\x04GW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xDFV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05}\x90\x85\x90\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\x90`\x84\x01[`@\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~V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1B\x91\x90a\x0B8V[a\x06%\x91\x90a\x0B\x95V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05}\x90\x85\x90\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\x90`d\x01a\x05\x19V[_a\x06\xDF\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\x07t\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07oW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFD\x91\x90a\x0B\xA8V[a\x07oW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[PPPV[``a\x07\x82\x84\x84_\x85a\x07\x8CV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\x04W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08hW`@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\x03\xDFV[__\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\x08\x90\x91\x90a\x0B\xC7V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xCAW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xCFV[``\x91P[P\x91P\x91Pa\x08\xDF\x82\x82\x86a\x08\xEAV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xF9WP\x81a\x07\x85V[\x82Q\x15a\t\tW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xDF\x91\x90a\x0B\xDDV[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\tDW__\xFD[PV[\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\x97Wa\t\x97a\tGV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC6Wa\t\xC6a\tGV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE1W__\xFD[\x845a\t\xEC\x81a\t#V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x03\x81a\t#V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x1EW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n.W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nHWa\nHa\tGV[a\n[` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9DV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\noW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA4W__\xFD[\x855a\n\xAF\x81a\t#V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC6\x81a\t#V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF7W__\xFD[Pa\x0B\0a\ttV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B%W__\xFD[Pa\x0B.a\ttV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BHW__\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[\x81\x81\x03\x81\x81\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[_` \x82\x84\x03\x12\x15a\x0B\xB8W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x85W__\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\xFE\xA2dipfsX\"\x12 \x82\xCFY\x81d\x94k\x8Fq\x9CM\x82\xEF^\xF6\x0E=\xDAW\xBE\xC7=\xE3\xE8\x87\xB6ny\x0B\xF7WqdsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 \xF4\xB6\x19\xDF\x9C\x12\xD9R'\xE4\xE7\xE3\xA8\x86\x8C\xF2k\x86E\xA0\xD5\xD8\xB2V\xEEc\xB7\x9DVu\x1A6dsolcC\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\0\xFBW_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\x93W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x01\xBBW\x80c\xF9\xCE\x0EZ\x14a\x01\xC3W\x80c\xFAv&\xD4\x14a\x01\xD6W\x80c\xFC\x0CTj\x14a\x01\xE3W__\xFD[\x80c\x91j\x17\xC6\x14a\x01~W\x80c\xB0FO\xDC\x14a\x01\x93W\x80c\xB5P\x8A\xA9\x14a\x01\x9BW\x80c\xBAAO\xA6\x14a\x01\xA3W__\xFD[\x80c?r\x86\xF4\x11a\0\xCEW\x80c?r\x86\xF4\x14a\x01DW\x80cIi\xBB\x03\x14a\x01LW\x80cf\xD9\xA9\xA0\x14a\x01TW\x80c\x85\"l\x81\x14a\x01iW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x1E\xD7\x83\x1C\x14a\x01\tW\x80c*\xDE8\x80\x14a\x01'W\x80c>^<#\x14a\x01=_\xFD[P`@Q\x7F\xCAf\x9F\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\x81Rs\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05\x94W__\xFD[PZ\xF1\x15\x80\x15a\x05\xA6W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x06 W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06D\x91\x90a\x17\x8CV[Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x06\x91W__\xFD[PZ\xF1\x15\x80\x15a\x06\xA3W=__>=_\xFD[PP`@Q\x7F\xCAf\x9F\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\x81Rs\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x92Pc\xCAf\x9F\xA7\x91P`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07\x1DW__\xFD[PZ\xF1\x15\x80\x15a\x07/W=__>=_\xFD[PP`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x84\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x84\x16\x92Pc\x7F\x81O5\x91P`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07\xBDW__\xFD[PZ\xF1\x15\x80\x15a\x07\xCFW=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\x1FW__\xFD[PZ\xF1\x15\x80\x15a\x081W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\x08\xC7\x93Pa\x01\0\x90\x91\x04`\x01`\x01`\xA0\x1B\x03\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x9DW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\xC1\x91\x90a\x17\xB2V[_a\x13GV[`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t*W__\xFD[PZ\xF1\x15\x80\x15a\t=_\xFD[PP`\x1FT`@Q\x7Fi2\x8D\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\x81Ra\x01\0\x90\x91\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01R`\x01`D\x83\x01R\x85\x16\x92Pci2\x8D\xEC\x91P`d\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\t\xBCW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\xE0\x91\x90a\x17\xB2V[Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\n-W__\xFD[PZ\xF1\x15\x80\x15a\n?W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\n\xDD\x93Pa\x01\0\x90\x91\x04`\x01`\x01`\xA0\x1B\x03\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\n\xABW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xCF\x91\x90a\x17\xB2V[g\r\xE0\xB6\xB3\xA7d\0\0a\x13GV[PPPV[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x03\xE7W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x0B5\x90a\x17;V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0Ba\x90a\x17;V[\x80\x15a\x0B\xACW\x80`\x1F\x10a\x0B\x83Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\xACV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\x8FW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x0CCW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0B\xF0W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0B\x05V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x03\xE7W\x83\x82\x90_R` _ \x01\x80Ta\x0C\x9B\x90a\x17;V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C\xC7\x90a\x17;V[\x80\x15a\r\x12W\x80`\x1F\x10a\x0C\xE9Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\r\x12V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0C\xF5W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0C~V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x03\xE7W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0E\x04W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\xB1W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\rIV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x03\xE7W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0E\xFAW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0E\xA7W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0E?V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x03\xE7W\x83\x82\x90_R` _ \x01\x80Ta\x0FR\x90a\x17;V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F~\x90a\x17;V[\x80\x15a\x0F\xC9W\x80`\x1F\x10a\x0F\xA0Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F\xC9V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\xACW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0F5V[`\x08T_\x90`\xFF\x16\x15a\x0F\xF4WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\x82W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\xA6\x91\x90a\x17\xB2V[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xAAW` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\x8CWPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\xA6W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x11\xCD\x91\x90\x81\x01\x90a\x17\xF6V[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x11\xEB\x92\x91\x90a\x18\xAAV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x12\x07W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12+\x91\x90a\x17\xB2V[P`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12\x97W__\xFD[PZ\xF1\x15\x80\x15a\x12\xA9W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x13\x1CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13@\x91\x90a\x17\x8CV[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x13\xB0W__\xFD[PZ\xFA\x15\x80\x15a\x13\xC2W=__>=_\xFD[PPPPPPV[a\r\x1E\x80a\x18\xCC\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x14\x17W\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x13\xF0V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15+W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`\x01`\x01`\xA0\x1B\x03\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x15\x11W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x14\xFB\x84\x86Qa\x14\"V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x14\xC1V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x14vV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x15\x89W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x15IV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15+W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x15\xDF`@\x88\x01\x82a\x14\"V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x15\xFA\x81\x83a\x157V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\xB9V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15+W`?\x19\x87\x86\x03\x01\x84Ra\x16S\x85\x83Qa\x14\"V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x167V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15+W`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x16\xC9`@\x87\x01\x82a\x157V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16\x8EV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x16\xF5W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x17\rW__\xFD[\x845\x93Pa\x17\x1D` \x86\x01a\x16\xDFV[\x92Pa\x17+`@\x86\x01a\x16\xDFV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x17OW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x17\x86W\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17\x9CW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x17\xABW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x17\xC2W__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x18\x06W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\x1CW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x18,W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18FWa\x18Fa\x17\xC9V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x18vWa\x18va\x17\xC9V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x18\x8DW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x18\xBC`@\x83\x01\x85a\x14\"V[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\x1E8\x03\x80a\r\x1E\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CHa\0\xD6_9_\x81\x81`S\x01R\x81\x81a\x01U\x01Ra\x02\x89\x01R_\x81\x81`\xA3\x01R\x81\x81a\x01\xC1\x01R\x81\x81a\x03(\x01Ra\x04b\x01Ra\x0CH_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x16\xF0\x11[\x14a\0NW\x80c%\xE2\xD6%\x14a\0\x9EW\x80cPcL\x0E\x14a\0\xC5W\x80c\x7F\x81O5\x14a\0\xDAW[__\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\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[a\0\xD8a\0\xD36`\x04a\t\xCEV[a\0\xEDV[\0[a\0\xD8a\0\xE86`\x04a\n\x90V[a\x01\x17V[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x14V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xBFV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x83V[`@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\x83\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B8V[`@Q\x7Fa{\xA07\0\0\0\0\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`$\x82\x01\x87\x90R\x85\x81\x16`D\x83\x01R_`d\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\x90ca{\xA07\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\xCCW__\xFD[PZ\xF1\x15\x80\x15a\x02\xDEW=__>=_\xFD[PP`@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\x86\x81\x16`\x04\x83\x01R_\x93P\x7F\0\0\0\0\0\0\0\0\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\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03nW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x92\x91\x90a\x0B8V[\x90P\x81\x81\x11a\x03\xE8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x03\xF3\x83\x83a\x0B|V[\x84Q\x90\x91P\x81\x10\x15a\x04GW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xDFV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05}\x90\x85\x90\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\x90`\x84\x01[`@\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~V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1B\x91\x90a\x0B8V[a\x06%\x91\x90a\x0B\x95V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05}\x90\x85\x90\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\x90`d\x01a\x05\x19V[_a\x06\xDF\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\x07t\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07oW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFD\x91\x90a\x0B\xA8V[a\x07oW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[PPPV[``a\x07\x82\x84\x84_\x85a\x07\x8CV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\x04W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08hW`@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\x03\xDFV[__\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\x08\x90\x91\x90a\x0B\xC7V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xCAW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xCFV[``\x91P[P\x91P\x91Pa\x08\xDF\x82\x82\x86a\x08\xEAV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xF9WP\x81a\x07\x85V[\x82Q\x15a\t\tW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xDF\x91\x90a\x0B\xDDV[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\tDW__\xFD[PV[\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\x97Wa\t\x97a\tGV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC6Wa\t\xC6a\tGV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE1W__\xFD[\x845a\t\xEC\x81a\t#V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x03\x81a\t#V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x1EW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n.W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nHWa\nHa\tGV[a\n[` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9DV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\noW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA4W__\xFD[\x855a\n\xAF\x81a\t#V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC6\x81a\t#V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF7W__\xFD[Pa\x0B\0a\ttV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B%W__\xFD[Pa\x0B.a\ttV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BHW__\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[\x81\x81\x03\x81\x81\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[_` \x82\x84\x03\x12\x15a\x0B\xB8W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x85W__\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\xFE\xA2dipfsX\"\x12 \x82\xCFY\x81d\x94k\x8Fq\x9CM\x82\xEF^\xF6\x0E=\xDAW\xBE\xC7=\xE3\xE8\x87\xB6ny\x0B\xF7WqdsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 \xF4\xB6\x19\xDF\x9C\x12\xD9R'\xE4\xE7\xE3\xA8\x86\x8C\xF2k\x86E\xA0\xD5\xD8\xB2V\xEEc\xB7\x9DVu\x1A6dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. -```solidity -event log(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `setUp()` and selector `0x0a9254e4`. -```solidity -function setUp() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setUpCall; - ///Container type for the return parameters of the [`setUp()`](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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl setUpReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for setUpCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = setUpReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "setUp()"; - const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - setUpReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. -```solidity -function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferCall { - #[allow(missing_docs)] - pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub sender: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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::Uint<256>, - ); - #[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::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferCall) -> Self { - (value.forkAtBlock, value.sender, value.receiver, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - forkAtBlock: tuple.0, - sender: tuple.1, - receiver: tuple.2, - amount: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl simulateForkAndTransferReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for simulateForkAndTransferCall { - type Parameters<'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::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = simulateForkAndTransferReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; - const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), - ::tokenize( - &self.sender, - ), - ::tokenize( - &self.receiver, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - simulateForkAndTransferReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testAvalonTBTCStrategy()` and selector `0x4969bb03`. -```solidity -function testAvalonTBTCStrategy() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testAvalonTBTCStrategyCall; - ///Container type for the return parameters of the [`testAvalonTBTCStrategy()`](testAvalonTBTCStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testAvalonTBTCStrategyReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testAvalonTBTCStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testAvalonTBTCStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testAvalonTBTCStrategyReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testAvalonTBTCStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testAvalonTBTCStrategyReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testAvalonTBTCStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testAvalonTBTCStrategyReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testAvalonTBTCStrategy()"; - const SELECTOR: [u8; 4] = [73u8, 105u8, 187u8, 3u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testAvalonTBTCStrategyReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `token()` and selector `0xfc0c546a`. -```solidity -function token() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`token()`](tokenCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for tokenCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "token()"; - const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`AvalonTBTCLendingStrategyForked`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum AvalonTBTCLendingStrategyForkedCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - setUp(setUpCall), - #[allow(missing_docs)] - simulateForkAndTransfer(simulateForkAndTransferCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - testAvalonTBTCStrategy(testAvalonTBTCStrategyCall), - #[allow(missing_docs)] - token(tokenCall), - } - #[automatically_derived] - impl AvalonTBTCLendingStrategyForkedCalls { - /// 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]] = &[ - [10u8, 146u8, 84u8, 228u8], - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [73u8, 105u8, 187u8, 3u8], - [102u8, 217u8, 169u8, 160u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [226u8, 12u8, 159u8, 113u8], - [249u8, 206u8, 14u8, 90u8], - [250u8, 118u8, 38u8, 212u8], - [252u8, 12u8, 84u8, 106u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for AvalonTBTCLendingStrategyForkedCalls { - const NAME: &'static str = "AvalonTBTCLendingStrategyForkedCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 16usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::setUp(_) => ::SELECTOR, - Self::simulateForkAndTransfer(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::testAvalonTBTCStrategy(_) => { - ::SELECTOR - } - Self::token(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(AvalonTBTCLendingStrategyForkedCalls::setUp) - } - setUp - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonTBTCLendingStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonTBTCLendingStrategyForkedCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonTBTCLendingStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonTBTCLendingStrategyForkedCalls::targetContracts) - } - targetContracts - }, - { - fn testAvalonTBTCStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - AvalonTBTCLendingStrategyForkedCalls::testAvalonTBTCStrategy, - ) - } - testAvalonTBTCStrategy - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - AvalonTBTCLendingStrategyForkedCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonTBTCLendingStrategyForkedCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonTBTCLendingStrategyForkedCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonTBTCLendingStrategyForkedCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonTBTCLendingStrategyForkedCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(AvalonTBTCLendingStrategyForkedCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonTBTCLendingStrategyForkedCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - AvalonTBTCLendingStrategyForkedCalls::simulateForkAndTransfer, - ) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(AvalonTBTCLendingStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(AvalonTBTCLendingStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonTBTCLendingStrategyForkedCalls::setUp) - } - setUp - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonTBTCLendingStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonTBTCLendingStrategyForkedCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonTBTCLendingStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonTBTCLendingStrategyForkedCalls::targetContracts) - } - targetContracts - }, - { - fn testAvalonTBTCStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - AvalonTBTCLendingStrategyForkedCalls::testAvalonTBTCStrategy, - ) - } - testAvalonTBTCStrategy - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - AvalonTBTCLendingStrategyForkedCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonTBTCLendingStrategyForkedCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonTBTCLendingStrategyForkedCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonTBTCLendingStrategyForkedCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonTBTCLendingStrategyForkedCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonTBTCLendingStrategyForkedCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonTBTCLendingStrategyForkedCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - AvalonTBTCLendingStrategyForkedCalls::simulateForkAndTransfer, - ) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonTBTCLendingStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonTBTCLendingStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::setUp(inner) => { - ::abi_encoded_size(inner) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testAvalonTBTCStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::token(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::setUp(inner) => { - ::abi_encode_raw(inner, out) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testAvalonTBTCStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::token(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - ///Container for all the [`AvalonTBTCLendingStrategyForked`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum AvalonTBTCLendingStrategyForkedEvents { - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl AvalonTBTCLendingStrategyForkedEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for AvalonTBTCLendingStrategyForkedEvents { - const NAME: &'static str = "AvalonTBTCLendingStrategyForkedEvents"; - const COUNT: usize = 22usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 AvalonTBTCLendingStrategyForkedEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`AvalonTBTCLendingStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`AvalonTBTCLendingStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> AvalonTBTCLendingStrategyForkedInstance { - AvalonTBTCLendingStrategyForkedInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - AvalonTBTCLendingStrategyForkedInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - AvalonTBTCLendingStrategyForkedInstance::::deploy_builder(provider) - } - /**A [`AvalonTBTCLendingStrategyForked`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`AvalonTBTCLendingStrategyForked`](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 AvalonTBTCLendingStrategyForkedInstance< - P, - N = alloy_contract::private::Ethereum, - > { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for AvalonTBTCLendingStrategyForkedInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("AvalonTBTCLendingStrategyForkedInstance") - .field(&self.address) - .finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > AvalonTBTCLendingStrategyForkedInstance { - /**Creates a new wrapper around an on-chain [`AvalonTBTCLendingStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`AvalonTBTCLendingStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 AvalonTBTCLendingStrategyForkedInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider( - self, - ) -> AvalonTBTCLendingStrategyForkedInstance { - AvalonTBTCLendingStrategyForkedInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > AvalonTBTCLendingStrategyForkedInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`setUp`] function. - pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { - self.call_builder(&setUpCall) - } - ///Creates a new call builder for the [`simulateForkAndTransfer`] function. - pub fn simulateForkAndTransfer( - &self, - forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - sender: alloy::sol_types::private::Address, - receiver: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { - self.call_builder( - &simulateForkAndTransferCall { - forkAtBlock, - sender, - receiver, - amount, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`testAvalonTBTCStrategy`] function. - pub fn testAvalonTBTCStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testAvalonTBTCStrategyCall, N> { - self.call_builder(&testAvalonTBTCStrategyCall) - } - ///Creates a new call builder for the [`token`] function. - pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { - self.call_builder(&tokenCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > AvalonTBTCLendingStrategyForkedInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/avalon_wbtc_lending_strategy_forked.rs b/crates/bindings/src/avalon_wbtc_lending_strategy_forked.rs deleted file mode 100644 index f890af4b4..000000000 --- a/crates/bindings/src/avalon_wbtc_lending_strategy_forked.rs +++ /dev/null @@ -1,8013 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface AvalonWBTCLendingStrategyForked { - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function setUp() external; - function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function testAvalonWBTCStrategy() external; - function token() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "setUp", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "simulateForkAndTransfer", - "inputs": [ - { - "name": "forkAtBlock", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "sender", - "type": "address", - "internalType": "address" - }, - { - "name": "receiver", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testAvalonWBTCStrategy", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "token", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IERC20" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 AvalonWBTCLendingStrategyForked { - use super::*; - use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15`+W__\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16t\x03\xC7\x05K\xCB9\xF7\xB2\xE5\xB2\xC7\xAC\xB3u\x83\xE3-p\xCF\xA3\0\x17\x90Ua%\xD8\x80a\0a_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xFBW_5`\xE0\x1C\x80c\xB0FO\xDC\x11a\0\x93W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x01\xBBW\x80c\xF9\xCE\x0EZ\x14a\x01\xC3W\x80c\xFAv&\xD4\x14a\x01\xD6W\x80c\xFC\x0CTj\x14a\x01\xE3W__\xFD[\x80c\xB0FO\xDC\x14a\x01\x8BW\x80c\xB5P\x8A\xA9\x14a\x01\x93W\x80c\xBAAO\xA6\x14a\x01\x9BW\x80c\xBA\xB7\x13{\x14a\x01\xB3W__\xFD[\x80c?r\x86\xF4\x11a\0\xCEW\x80c?r\x86\xF4\x14a\x01DW\x80cf\xD9\xA9\xA0\x14a\x01LW\x80c\x85\"l\x81\x14a\x01aW\x80c\x91j\x17\xC6\x14a\x01vW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x1E\xD7\x83\x1C\x14a\x01\tW\x80c*\xDE8\x80\x14a\x01'W\x80c>^<#\x14a\x01*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x10vV[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\0W\x83\x82\x90_R` _ \x01\x80Ta\x03u\x90a\x16\xF4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xA1\x90a\x16\xF4V[\x80\x15a\x03\xECW\x80`\x1F\x10a\x03\xC3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xECV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xCFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03XV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xFAV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x05I\x90a\x16\xF4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05u\x90a\x16\xF4V[\x80\x15a\x05\xC0W\x80`\x1F\x10a\x05\x97Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05\xC0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05\xA3W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06WW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x06\x04W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05\x19V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\x06\xAF\x90a\x16\xF4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06\xDB\x90a\x16\xF4V[\x80\x15a\x07&W\x80`\x1F\x10a\x06\xFDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07&V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\tW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x06\x92V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x08%W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x07\xD2W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07]V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\t(W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x08\xD5W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x08`V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\t\x80\x90a\x16\xF4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\t\xAC\x90a\x16\xF4V[\x80\x15a\t\xF7W\x80`\x1F\x10a\t\xCEWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\t\xF7V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t\xDAW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\tcV[`\x08T_\x90`\xFF\x16\x15a\n\"WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\n\xB0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xD4\x91\x90a\x17EV[\x14\x15\x90P\x90V[`@Qs\xD6\x89\x01v\xE8\xD9\x12\x14*\xC4\x89\xE8\xB5\xD8\xD9?\x8D\xE7M`\x90s5\xB3\xF1\xBF\xE7\xCB\xE1\xE9Z=\xC2\xAD\x05N\xB6\xF0\xD4\xC8y\xB6\x90_\x90\x83\x90\x83\x90a\x0B\x19\x90a\x13OV[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x0BVW=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0B\xD0W__\xFD[PZ\xF1\x15\x80\x15a\x0B\xE2W=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0CeW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x89\x91\x90a\x17\\V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\r\x1DW__\xFD[PZ\xF1\x15\x80\x15a\r/W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\r\x8CW__\xFD[PZ\xF1\x15\x80\x15a\r\x9EW=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\x0EA\x93Pa\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\x17W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E;\x91\x90a\x17EV[_a\x12\xCCV[`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0E\xA4W__\xFD[PZ\xF1\x15\x80\x15a\x0E\xB6W=__>=_\xFD[PP`\x1FT`@Q\x7Fi2\x8D\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\x81Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01R`\x01`D\x83\x01R\x85\x16\x92Pci2\x8D\xEC\x91P`d\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0F?W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0Fc\x91\x90a\x17EV[P`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\x10\x06\x91a\x01\0\x90\x04s\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\xD8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xFC\x91\x90a\x17EV[c\x05\xF5\xE1\0a\x12\xCCV[PPPV[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\x11W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x118\x91\x90\x81\x01\x90a\x17\xAFV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x11V\x92\x91\x90a\x18cV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11rW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\x96\x91\x90a\x17EV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12\x0FW__\xFD[PZ\xF1\x15\x80\x15a\x12!W=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x12\xA1W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xC5\x91\x90a\x17\\V[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x135W__\xFD[PZ\xFA\x15\x80\x15a\x13GW=__>=_\xFD[PPPPPPV[a\r\x1E\x80a\x18\x85\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x13\xA9W\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\x13uV[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\xCAW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x14\xB0W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x14\x9A\x84\x86Qa\x13\xB4V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x14`V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x14\x08V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x15(W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x14\xE8V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\xCAW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x15~`@\x88\x01\x82a\x13\xB4V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x15\x99\x81\x83a\x14\xD6V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15XV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\xCAW`?\x19\x87\x86\x03\x01\x84Ra\x15\xF2\x85\x83Qa\x13\xB4V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\xD6V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\xCAW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x16u`@\x87\x01\x82a\x14\xD6V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16-V[\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\x16\xAEW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x16\xC6W__\xFD[\x845\x93Pa\x16\xD6` \x86\x01a\x16\x8BV[\x92Pa\x16\xE4`@\x86\x01a\x16\x8BV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x17\x08W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x17?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`\"`\x04R`$_\xFD[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17UW__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17lW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x17{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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x17\xBFW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17\xD5W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x17\xE5W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17\xFFWa\x17\xFFa\x17\x82V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x18/Wa\x18/a\x17\x82V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x18FW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x18u`@\x83\x01\x85a\x13\xB4V[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\x1E8\x03\x80a\r\x1E\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CHa\0\xD6_9_\x81\x81`S\x01R\x81\x81a\x01U\x01Ra\x02\x89\x01R_\x81\x81`\xA3\x01R\x81\x81a\x01\xC1\x01R\x81\x81a\x03(\x01Ra\x04b\x01Ra\x0CH_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x16\xF0\x11[\x14a\0NW\x80c%\xE2\xD6%\x14a\0\x9EW\x80cPcL\x0E\x14a\0\xC5W\x80c\x7F\x81O5\x14a\0\xDAW[__\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\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[a\0\xD8a\0\xD36`\x04a\t\xCEV[a\0\xEDV[\0[a\0\xD8a\0\xE86`\x04a\n\x90V[a\x01\x17V[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x14V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xBFV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x83V[`@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\x83\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B8V[`@Q\x7Fa{\xA07\0\0\0\0\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`$\x82\x01\x87\x90R\x85\x81\x16`D\x83\x01R_`d\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\x90ca{\xA07\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\xCCW__\xFD[PZ\xF1\x15\x80\x15a\x02\xDEW=__>=_\xFD[PP`@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\x86\x81\x16`\x04\x83\x01R_\x93P\x7F\0\0\0\0\0\0\0\0\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\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03nW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x92\x91\x90a\x0B8V[\x90P\x81\x81\x11a\x03\xE8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x03\xF3\x83\x83a\x0B|V[\x84Q\x90\x91P\x81\x10\x15a\x04GW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xDFV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05}\x90\x85\x90\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\x90`\x84\x01[`@\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~V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1B\x91\x90a\x0B8V[a\x06%\x91\x90a\x0B\x95V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05}\x90\x85\x90\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\x90`d\x01a\x05\x19V[_a\x06\xDF\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\x07t\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07oW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFD\x91\x90a\x0B\xA8V[a\x07oW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[PPPV[``a\x07\x82\x84\x84_\x85a\x07\x8CV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\x04W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08hW`@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\x03\xDFV[__\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\x08\x90\x91\x90a\x0B\xC7V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xCAW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xCFV[``\x91P[P\x91P\x91Pa\x08\xDF\x82\x82\x86a\x08\xEAV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xF9WP\x81a\x07\x85V[\x82Q\x15a\t\tW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xDF\x91\x90a\x0B\xDDV[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\tDW__\xFD[PV[\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\x97Wa\t\x97a\tGV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC6Wa\t\xC6a\tGV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE1W__\xFD[\x845a\t\xEC\x81a\t#V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x03\x81a\t#V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x1EW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n.W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nHWa\nHa\tGV[a\n[` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9DV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\noW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA4W__\xFD[\x855a\n\xAF\x81a\t#V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC6\x81a\t#V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF7W__\xFD[Pa\x0B\0a\ttV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B%W__\xFD[Pa\x0B.a\ttV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BHW__\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[\x81\x81\x03\x81\x81\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[_` \x82\x84\x03\x12\x15a\x0B\xB8W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x85W__\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\xFE\xA2dipfsX\"\x12 \x82\xCFY\x81d\x94k\x8Fq\x9CM\x82\xEF^\xF6\x0E=\xDAW\xBE\xC7=\xE3\xE8\x87\xB6ny\x0B\xF7WqdsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 \xF6}\x88\x98x7T\xF0\x89\xFBv\xDB[\"E\x9E\xF5\x8A\x13z\x05\xD7\xAD\xF2\xD2\xF8v\xFE\x84\xB0\xF0\xF5dsolcC\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\0\xFBW_5`\xE0\x1C\x80c\xB0FO\xDC\x11a\0\x93W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x01\xBBW\x80c\xF9\xCE\x0EZ\x14a\x01\xC3W\x80c\xFAv&\xD4\x14a\x01\xD6W\x80c\xFC\x0CTj\x14a\x01\xE3W__\xFD[\x80c\xB0FO\xDC\x14a\x01\x8BW\x80c\xB5P\x8A\xA9\x14a\x01\x93W\x80c\xBAAO\xA6\x14a\x01\x9BW\x80c\xBA\xB7\x13{\x14a\x01\xB3W__\xFD[\x80c?r\x86\xF4\x11a\0\xCEW\x80c?r\x86\xF4\x14a\x01DW\x80cf\xD9\xA9\xA0\x14a\x01LW\x80c\x85\"l\x81\x14a\x01aW\x80c\x91j\x17\xC6\x14a\x01vW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x1E\xD7\x83\x1C\x14a\x01\tW\x80c*\xDE8\x80\x14a\x01'W\x80c>^<#\x14a\x01*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x10vV[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\0W\x83\x82\x90_R` _ \x01\x80Ta\x03u\x90a\x16\xF4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xA1\x90a\x16\xF4V[\x80\x15a\x03\xECW\x80`\x1F\x10a\x03\xC3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xECV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xCFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03XV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xFAV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x05I\x90a\x16\xF4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05u\x90a\x16\xF4V[\x80\x15a\x05\xC0W\x80`\x1F\x10a\x05\x97Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05\xC0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05\xA3W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06WW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x06\x04W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05\x19V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\x06\xAF\x90a\x16\xF4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06\xDB\x90a\x16\xF4V[\x80\x15a\x07&W\x80`\x1F\x10a\x06\xFDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07&V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\tW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x06\x92V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x08%W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x07\xD2W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07]V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\t(W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x08\xD5W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x08`V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\t\x80\x90a\x16\xF4V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\t\xAC\x90a\x16\xF4V[\x80\x15a\t\xF7W\x80`\x1F\x10a\t\xCEWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\t\xF7V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t\xDAW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\tcV[`\x08T_\x90`\xFF\x16\x15a\n\"WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\n\xB0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xD4\x91\x90a\x17EV[\x14\x15\x90P\x90V[`@Qs\xD6\x89\x01v\xE8\xD9\x12\x14*\xC4\x89\xE8\xB5\xD8\xD9?\x8D\xE7M`\x90s5\xB3\xF1\xBF\xE7\xCB\xE1\xE9Z=\xC2\xAD\x05N\xB6\xF0\xD4\xC8y\xB6\x90_\x90\x83\x90\x83\x90a\x0B\x19\x90a\x13OV[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x0BVW=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0B\xD0W__\xFD[PZ\xF1\x15\x80\x15a\x0B\xE2W=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0CeW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\x89\x91\x90a\x17\\V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\r\x1DW__\xFD[PZ\xF1\x15\x80\x15a\r/W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\r\x8CW__\xFD[PZ\xF1\x15\x80\x15a\r\x9EW=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\x0EA\x93Pa\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\x17W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E;\x91\x90a\x17EV[_a\x12\xCCV[`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0E\xA4W__\xFD[PZ\xF1\x15\x80\x15a\x0E\xB6W=__>=_\xFD[PP`\x1FT`@Q\x7Fi2\x8D\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\x81Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01R`\x01`D\x83\x01R\x85\x16\x92Pci2\x8D\xEC\x91P`d\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0F?W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0Fc\x91\x90a\x17EV[P`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\x10\x06\x91a\x01\0\x90\x04s\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\xD8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xFC\x91\x90a\x17EV[c\x05\xF5\xE1\0a\x12\xCCV[PPPV[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\x11W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x118\x91\x90\x81\x01\x90a\x17\xAFV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x11V\x92\x91\x90a\x18cV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11rW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\x96\x91\x90a\x17EV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12\x0FW__\xFD[PZ\xF1\x15\x80\x15a\x12!W=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x12\xA1W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xC5\x91\x90a\x17\\V[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x135W__\xFD[PZ\xFA\x15\x80\x15a\x13GW=__>=_\xFD[PPPPPPV[a\r\x1E\x80a\x18\x85\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x13\xA9W\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\x13uV[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\xCAW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x14\xB0W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x14\x9A\x84\x86Qa\x13\xB4V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x14`V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x14\x08V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x15(W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x14\xE8V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\xCAW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x15~`@\x88\x01\x82a\x13\xB4V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x15\x99\x81\x83a\x14\xD6V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15XV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\xCAW`?\x19\x87\x86\x03\x01\x84Ra\x15\xF2\x85\x83Qa\x13\xB4V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\xD6V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14\xCAW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x16u`@\x87\x01\x82a\x14\xD6V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16-V[\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\x16\xAEW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x16\xC6W__\xFD[\x845\x93Pa\x16\xD6` \x86\x01a\x16\x8BV[\x92Pa\x16\xE4`@\x86\x01a\x16\x8BV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x17\x08W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x17?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`\"`\x04R`$_\xFD[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17UW__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17lW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x17{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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x17\xBFW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17\xD5W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x17\xE5W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17\xFFWa\x17\xFFa\x17\x82V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x18/Wa\x18/a\x17\x82V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x18FW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x18u`@\x83\x01\x85a\x13\xB4V[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\x1E8\x03\x80a\r\x1E\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CHa\0\xD6_9_\x81\x81`S\x01R\x81\x81a\x01U\x01Ra\x02\x89\x01R_\x81\x81`\xA3\x01R\x81\x81a\x01\xC1\x01R\x81\x81a\x03(\x01Ra\x04b\x01Ra\x0CH_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x16\xF0\x11[\x14a\0NW\x80c%\xE2\xD6%\x14a\0\x9EW\x80cPcL\x0E\x14a\0\xC5W\x80c\x7F\x81O5\x14a\0\xDAW[__\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\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[a\0\xD8a\0\xD36`\x04a\t\xCEV[a\0\xEDV[\0[a\0\xD8a\0\xE86`\x04a\n\x90V[a\x01\x17V[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x14V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xBFV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x83V[`@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\x83\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B8V[`@Q\x7Fa{\xA07\0\0\0\0\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`$\x82\x01\x87\x90R\x85\x81\x16`D\x83\x01R_`d\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\x90ca{\xA07\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\xCCW__\xFD[PZ\xF1\x15\x80\x15a\x02\xDEW=__>=_\xFD[PP`@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\x86\x81\x16`\x04\x83\x01R_\x93P\x7F\0\0\0\0\0\0\0\0\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\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03nW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x92\x91\x90a\x0B8V[\x90P\x81\x81\x11a\x03\xE8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x03\xF3\x83\x83a\x0B|V[\x84Q\x90\x91P\x81\x10\x15a\x04GW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xDFV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05}\x90\x85\x90\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\x90`\x84\x01[`@\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~V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1B\x91\x90a\x0B8V[a\x06%\x91\x90a\x0B\x95V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05}\x90\x85\x90\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\x90`d\x01a\x05\x19V[_a\x06\xDF\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\x07t\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07oW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFD\x91\x90a\x0B\xA8V[a\x07oW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[PPPV[``a\x07\x82\x84\x84_\x85a\x07\x8CV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\x04W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08hW`@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\x03\xDFV[__\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\x08\x90\x91\x90a\x0B\xC7V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xCAW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xCFV[``\x91P[P\x91P\x91Pa\x08\xDF\x82\x82\x86a\x08\xEAV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xF9WP\x81a\x07\x85V[\x82Q\x15a\t\tW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xDF\x91\x90a\x0B\xDDV[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\tDW__\xFD[PV[\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\x97Wa\t\x97a\tGV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC6Wa\t\xC6a\tGV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE1W__\xFD[\x845a\t\xEC\x81a\t#V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x03\x81a\t#V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x1EW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n.W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nHWa\nHa\tGV[a\n[` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9DV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\noW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA4W__\xFD[\x855a\n\xAF\x81a\t#V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC6\x81a\t#V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF7W__\xFD[Pa\x0B\0a\ttV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B%W__\xFD[Pa\x0B.a\ttV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BHW__\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[\x81\x81\x03\x81\x81\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[_` \x82\x84\x03\x12\x15a\x0B\xB8W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x85W__\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\xFE\xA2dipfsX\"\x12 \x82\xCFY\x81d\x94k\x8Fq\x9CM\x82\xEF^\xF6\x0E=\xDAW\xBE\xC7=\xE3\xE8\x87\xB6ny\x0B\xF7WqdsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 \xF6}\x88\x98x7T\xF0\x89\xFBv\xDB[\"E\x9E\xF5\x8A\x13z\x05\xD7\xAD\xF2\xD2\xF8v\xFE\x84\xB0\xF0\xF5dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. -```solidity -event log(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `setUp()` and selector `0x0a9254e4`. -```solidity -function setUp() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setUpCall; - ///Container type for the return parameters of the [`setUp()`](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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl setUpReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for setUpCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = setUpReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "setUp()"; - const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - setUpReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. -```solidity -function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferCall { - #[allow(missing_docs)] - pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub sender: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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::Uint<256>, - ); - #[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::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferCall) -> Self { - (value.forkAtBlock, value.sender, value.receiver, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - forkAtBlock: tuple.0, - sender: tuple.1, - receiver: tuple.2, - amount: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl simulateForkAndTransferReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for simulateForkAndTransferCall { - type Parameters<'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::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = simulateForkAndTransferReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; - const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), - ::tokenize( - &self.sender, - ), - ::tokenize( - &self.receiver, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - simulateForkAndTransferReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testAvalonWBTCStrategy()` and selector `0xbab7137b`. -```solidity -function testAvalonWBTCStrategy() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testAvalonWBTCStrategyCall; - ///Container type for the return parameters of the [`testAvalonWBTCStrategy()`](testAvalonWBTCStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testAvalonWBTCStrategyReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testAvalonWBTCStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testAvalonWBTCStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testAvalonWBTCStrategyReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testAvalonWBTCStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testAvalonWBTCStrategyReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testAvalonWBTCStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testAvalonWBTCStrategyReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testAvalonWBTCStrategy()"; - const SELECTOR: [u8; 4] = [186u8, 183u8, 19u8, 123u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testAvalonWBTCStrategyReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `token()` and selector `0xfc0c546a`. -```solidity -function token() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`token()`](tokenCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for tokenCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "token()"; - const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`AvalonWBTCLendingStrategyForked`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum AvalonWBTCLendingStrategyForkedCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - setUp(setUpCall), - #[allow(missing_docs)] - simulateForkAndTransfer(simulateForkAndTransferCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - testAvalonWBTCStrategy(testAvalonWBTCStrategyCall), - #[allow(missing_docs)] - token(tokenCall), - } - #[automatically_derived] - impl AvalonWBTCLendingStrategyForkedCalls { - /// 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]] = &[ - [10u8, 146u8, 84u8, 228u8], - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [102u8, 217u8, 169u8, 160u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [186u8, 183u8, 19u8, 123u8], - [226u8, 12u8, 159u8, 113u8], - [249u8, 206u8, 14u8, 90u8], - [250u8, 118u8, 38u8, 212u8], - [252u8, 12u8, 84u8, 106u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for AvalonWBTCLendingStrategyForkedCalls { - const NAME: &'static str = "AvalonWBTCLendingStrategyForkedCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 16usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::setUp(_) => ::SELECTOR, - Self::simulateForkAndTransfer(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::testAvalonWBTCStrategy(_) => { - ::SELECTOR - } - Self::token(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(AvalonWBTCLendingStrategyForkedCalls::setUp) - } - setUp - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonWBTCLendingStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonWBTCLendingStrategyForkedCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonWBTCLendingStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonWBTCLendingStrategyForkedCalls::targetContracts) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - AvalonWBTCLendingStrategyForkedCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonWBTCLendingStrategyForkedCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonWBTCLendingStrategyForkedCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonWBTCLendingStrategyForkedCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonWBTCLendingStrategyForkedCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(AvalonWBTCLendingStrategyForkedCalls::failed) - } - failed - }, - { - fn testAvalonWBTCStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - AvalonWBTCLendingStrategyForkedCalls::testAvalonWBTCStrategy, - ) - } - testAvalonWBTCStrategy - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonWBTCLendingStrategyForkedCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - AvalonWBTCLendingStrategyForkedCalls::simulateForkAndTransfer, - ) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(AvalonWBTCLendingStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(AvalonWBTCLendingStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLendingStrategyForkedCalls::setUp) - } - setUp - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLendingStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLendingStrategyForkedCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLendingStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLendingStrategyForkedCalls::targetContracts) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - AvalonWBTCLendingStrategyForkedCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLendingStrategyForkedCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLendingStrategyForkedCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLendingStrategyForkedCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLendingStrategyForkedCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLendingStrategyForkedCalls::failed) - } - failed - }, - { - fn testAvalonWBTCStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - AvalonWBTCLendingStrategyForkedCalls::testAvalonWBTCStrategy, - ) - } - testAvalonWBTCStrategy - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLendingStrategyForkedCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - AvalonWBTCLendingStrategyForkedCalls::simulateForkAndTransfer, - ) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLendingStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLendingStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::setUp(inner) => { - ::abi_encoded_size(inner) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testAvalonWBTCStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::token(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::setUp(inner) => { - ::abi_encode_raw(inner, out) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testAvalonWBTCStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::token(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - ///Container for all the [`AvalonWBTCLendingStrategyForked`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum AvalonWBTCLendingStrategyForkedEvents { - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl AvalonWBTCLendingStrategyForkedEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for AvalonWBTCLendingStrategyForkedEvents { - const NAME: &'static str = "AvalonWBTCLendingStrategyForkedEvents"; - const COUNT: usize = 22usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 AvalonWBTCLendingStrategyForkedEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`AvalonWBTCLendingStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`AvalonWBTCLendingStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> AvalonWBTCLendingStrategyForkedInstance { - AvalonWBTCLendingStrategyForkedInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - AvalonWBTCLendingStrategyForkedInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - AvalonWBTCLendingStrategyForkedInstance::::deploy_builder(provider) - } - /**A [`AvalonWBTCLendingStrategyForked`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`AvalonWBTCLendingStrategyForked`](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 AvalonWBTCLendingStrategyForkedInstance< - P, - N = alloy_contract::private::Ethereum, - > { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for AvalonWBTCLendingStrategyForkedInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("AvalonWBTCLendingStrategyForkedInstance") - .field(&self.address) - .finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > AvalonWBTCLendingStrategyForkedInstance { - /**Creates a new wrapper around an on-chain [`AvalonWBTCLendingStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`AvalonWBTCLendingStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 AvalonWBTCLendingStrategyForkedInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider( - self, - ) -> AvalonWBTCLendingStrategyForkedInstance { - AvalonWBTCLendingStrategyForkedInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > AvalonWBTCLendingStrategyForkedInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`setUp`] function. - pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { - self.call_builder(&setUpCall) - } - ///Creates a new call builder for the [`simulateForkAndTransfer`] function. - pub fn simulateForkAndTransfer( - &self, - forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - sender: alloy::sol_types::private::Address, - receiver: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { - self.call_builder( - &simulateForkAndTransferCall { - forkAtBlock, - sender, - receiver, - amount, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`testAvalonWBTCStrategy`] function. - pub fn testAvalonWBTCStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testAvalonWBTCStrategyCall, N> { - self.call_builder(&testAvalonWBTCStrategyCall) - } - ///Creates a new call builder for the [`token`] function. - pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { - self.call_builder(&tokenCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > AvalonWBTCLendingStrategyForkedInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/avalon_wbtc_lst_strategy_forked.rs b/crates/bindings/src/avalon_wbtc_lst_strategy_forked.rs deleted file mode 100644 index 640154528..000000000 --- a/crates/bindings/src/avalon_wbtc_lst_strategy_forked.rs +++ /dev/null @@ -1,8004 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface AvalonWBTCLstStrategyForked { - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function setUp() external; - function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function testWbtcLstStrategy() external; - function token() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "setUp", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "simulateForkAndTransfer", - "inputs": [ - { - "name": "forkAtBlock", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "sender", - "type": "address", - "internalType": "address" - }, - { - "name": "receiver", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testWbtcLstStrategy", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "token", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IERC20" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 AvalonWBTCLstStrategyForked { - use super::*; - use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15`+W__\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16t\x03\xC7\x05K\xCB9\xF7\xB2\xE5\xB2\xC7\xAC\xB3u\x83\xE3-p\xCF\xA3\0\x17\x90UaBp\x80a\0a_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xFBW_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\x93W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x01\xBBW\x80c\xF9\xCE\x0EZ\x14a\x01\xC3W\x80c\xFAv&\xD4\x14a\x01\xD6W\x80c\xFC\x0CTj\x14a\x01\xE3W__\xFD[\x80c\x91j\x17\xC6\x14a\x01~W\x80c\xB0FO\xDC\x14a\x01\x93W\x80c\xB5P\x8A\xA9\x14a\x01\x9BW\x80c\xBAAO\xA6\x14a\x01\xA3W__\xFD[\x80c?r\x86\xF4\x11a\0\xCEW\x80c?r\x86\xF4\x14a\x01DW\x80cB\xB0\x1C\xFE\x14a\x01LW\x80cf\xD9\xA9\xA0\x14a\x01TW\x80c\x85\"l\x81\x14a\x01iW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x1E\xD7\x83\x1C\x14a\x01\tW\x80c*\xDE8\x80\x14a\x01'W\x80c>^<#\x14a\x01*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x10\xA7V[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\0W\x83\x82\x90_R` _ \x01\x80Ta\x03u\x90a\x17?V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xA1\x90a\x17?V[\x80\x15a\x03\xECW\x80`\x1F\x10a\x03\xC3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xECV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xCFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03XV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xFAV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[_sT\x1F\xD7IA\x9C\xA8\x06\xA8\xBC}\xA8\xAC#\xD3F\xF2\xDF\x8Bw\x90P_s\xCC\tf\xD8A\x8DA,Y\x9Ad!\xB7`\xA8G\xEB\x16\x9A\x8C\x90P_sI\xB0r\x15\x85d\xDB60E\x18\xFF\xA3{\x1C\xFC\x13\x91j\x90s\xBAF\xFC\xC1kFM\x97\x871Ag\xBD\xD9\xF1\xCE(@[\xA1\x7FVdR\x02@\xA4kK>\x96U\xC2\x0C\xC3\xF9\xE0\x84\x96\xA9\xB7F\xA4x\xE4v\xAE>\x04\xD6\xC8\xFC1\x7Fh\x99\xA7\xE1;e_\xA3g \x8C\xB2|n\xAA$\x107\r\x15e\xDC\x1F_\x11\x85:\x1E\x8C\xBE\xF03\x86\x86`@Qa\x05\xA1\x90a\x13\x80V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x96\x87\x16\x81R\x94\x86\x16` \x86\x01R`@\x85\x01\x93\x90\x93R``\x84\x01\x91\x90\x91R\x83\x16`\x80\x83\x01R\x90\x91\x16`\xA0\x82\x01R`\xC0\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x05\xFEW=__>=_\xFD[P\x90P_s.e\0\xA7\xAD\xD9\xA7\x88u:\x89~N4w\xF6Q\xC6\x12\xEB\x90P_s5\xB3\xF1\xBF\xE7\xCB\xE1\xE9Z=\xC2\xAD\x05N\xB6\xF0\xD4\xC8y\xB6\x90P_\x82\x82`@Qa\x06@\x90a\x13\x8DV[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x06}W=__>=_\xFD[P\x90P_\x84\x82`@Qa\x06\x8F\x90a\x13\x9AV[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x06\xCCW=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07FW__\xFD[PZ\xF1\x15\x80\x15a\x07XW=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x07\xDBW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xFF\x91\x90a\x17\x90V[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\x81R`\x01`\x04\x82\x01Ra\x08\x97\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\x08mW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\x91\x91\x90a\x17\xB6V[_a\x12\xFDV[`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t*W__\xFD[PZ\xF1\x15\x80\x15a\t=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t\x99W__\xFD[PZ\xF1\x15\x80\x15a\t\xABW=__>=_\xFD[PP`@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\x81R`\x01`\x04\x82\x01Ra\nN\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\n\x1CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n@\x91\x90a\x17\xB6V[g\r\xE0\xB6\xB3\xA7d\0\0a\x12\xFDV[PPPPPPPV[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\n\xAA\x90a\x17?V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n\xD6\x90a\x17?V[\x80\x15a\x0B!W\x80`\x1F\x10a\n\xF8Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B!V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\x04W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x0B\xB8W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0BeW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\nzV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\x0C\x10\x90a\x17?V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C<\x90a\x17?V[\x80\x15a\x0C\x87W\x80`\x1F\x10a\x0C^Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C\x87V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0CjW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0B\xF3V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\x86W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r3W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xBEV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0E\x89W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0E6W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\r\xC1V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\x0E\xE1\x90a\x17?V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F\r\x90a\x17?V[\x80\x15a\x0FXW\x80`\x1F\x10a\x0F/Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0FXV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F;W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0E\xC4V[`\x08T_\x90`\xFF\x16\x15a\x0F\x83WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\x11W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x105\x91\x90a\x17\xB6V[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11BW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x11i\x91\x90\x81\x01\x90a\x17\xFAV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x11\x87\x92\x91\x90a\x18\xAEV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11\xA3W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\xC7\x91\x90a\x17\xB6V[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12@W__\xFD[PZ\xF1\x15\x80\x15a\x12RW=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x12\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xF6\x91\x90a\x17\x90V[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x13fW__\xFD[PZ\xFA\x15\x80\x15a\x13xW=__>=_\xFD[PPPPPPV[a\x0F-\x80a\x18\xD0\x839\x01\x90V[a\r\x1E\x80a'\xFD\x839\x01\x90V[a\r \x80a5\x1B\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x13\xF4W\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\x13\xC0V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x15W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x14\xFBW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x14\xE5\x84\x86Qa\x13\xFFV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x14\xABV[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x14SV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x15sW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x153V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x15W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x15\xC9`@\x88\x01\x82a\x13\xFFV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x15\xE4\x81\x83a\x15!V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\xA3V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x15W`?\x19\x87\x86\x03\x01\x84Ra\x16=\x85\x83Qa\x13\xFFV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16!V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x15W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x16\xC0`@\x87\x01\x82a\x15!V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16xV[\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\x16\xF9W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x17\x11W__\xFD[\x845\x93Pa\x17!` \x86\x01a\x16\xD6V[\x92Pa\x17/`@\x86\x01a\x16\xD6V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x17SW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x17\x8AW\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17\xA0W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x17\xAFW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x17\xC6W__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x18\nW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18 W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x180W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18JWa\x18Ja\x17\xCDV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x18zWa\x18za\x17\xCDV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x18\x91W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x18\xC0`@\x83\x01\x85a\x13\xFFV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFEa\x01@`@R4\x80\x15a\0\x10W__\xFD[P`@Qa\x0F-8\x03\x80a\x0F-\x839\x81\x01`@\x81\x90Ra\0/\x91a\0sV[`\x01`\x01`\xA0\x1B\x03\x95\x86\x16`\x80R\x93\x85\x16`\xA0R`\xC0\x92\x90\x92R`\xE0R\x82\x16a\x01\0R\x16a\x01 Ra\0\xE3V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0pW__\xFD[PV[______`\xC0\x87\x89\x03\x12\x15a\0\x88W__\xFD[\x86Qa\0\x93\x81a\0\\V[` \x88\x01Q\x90\x96Pa\0\xA4\x81a\0\\V[`@\x88\x01Q``\x89\x01Q`\x80\x8A\x01Q\x92\x97P\x90\x95P\x93Pa\0\xC4\x81a\0\\V[`\xA0\x88\x01Q\x90\x92Pa\0\xD5\x81a\0\\V[\x80\x91PP\x92\x95P\x92\x95P\x92\x95V[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\r\xC6a\x01g_9_\x81\x81a\x01.\x01R\x81\x81a\x04\xFC\x01Ra\x05>\x01R_\x81\x81a\x01U\x01Ra\x03R\x01R_\x81\x81a\x01\xB1\x01Ra\x03\xC1\x01R_\x81\x81a\x01|\x01Ra\x02\x88\x01R_\x81\x81`\xDF\x01R\x81\x81a\x03t\x01Ra\x03\xF0\x01R_\x81\x81`\x8E\x01R\x81\x81a\x02;\x01Ra\x02\xB7\x01Ra\r\xC6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\x85W_5`\xE0\x1C\x80c\xADt}\xE6\x11a\0XW\x80c\xADt}\xE6\x14a\x01)W\x80c\xB9\x93|\xCB\x14a\x01PW\x80c\xC8\xC7\xF7\x01\x14a\x01wW\x80c\xE3L\xEF\x86\x14a\x01\xACW__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0\x89W\x80cN=\xF3\xF4\x14a\0\xDAW\x80cPcL\x0E\x14a\x01\x01W\x80c\x7F\x81O5\x14a\x01\x16W[__\xFD[a\0\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\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\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\x81V[a\x01\x14a\x01\x0F6`\x04a\x0BgV[a\x01\xD3V[\0[a\x01\x14a\x01$6`\x04a\x0C)V[a\x01\xFDV[a\0\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\x81V[a\0\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\x81V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xD1V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\xE8\x91\x90a\x0C\xADV[\x90Pa\x01\xF6\x85\x85\x85\x84a\x01\xFDV[PPPPPV[a\x02\x1Fs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x9AV[a\x02`s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x036\x91\x90a\x0C\xD1V[\x90Pa\x03\x99s\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\x7F\0\0\0\0\0\0\0\0\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\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x82\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04KW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04o\x91\x90a\x0C\xD1V[\x83Q\x90\x91P\x81\x10\x15a\x04\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[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\x85\x83a\x07YV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x06X\x90\x85\x90\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\x90`\x84\x01[`@\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\x07\xB4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF6\x91\x90a\x0C\xD1V[a\x07\0\x91\x90a\x0C\xE8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x06X\x90\x85\x90\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\x90`d\x01a\x05\xF4V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07\xAF\x90\x84\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\x90`d\x01a\x05\xF4V[PPPV[_a\x08\x15\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\x08\xBF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\xAFW\x80\x80` \x01\x90Q\x81\x01\x90a\x083\x91\x90a\r&V[a\x07\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\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\x04\xD9V[``a\x08\xCD\x84\x84_\x85a\x08\xD7V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\tiW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x04\xD9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\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`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x04\xD9V[__\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\n\x0F\x91\x90a\rEV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\nIW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\nNV[``\x91P[P\x91P\x91Pa\n^\x82\x82\x86a\niV[\x97\x96PPPPPPPV[``\x83\x15a\nxWP\x81a\x08\xD0V[\x82Q\x15a\n\x88W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x04\xD9\x91\x90a\r[V[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\xDDW__\xFD[PV[\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\x0B0Wa\x0B0a\n\xE0V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0B_Wa\x0B_a\n\xE0V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0BzW__\xFD[\x845a\x0B\x85\x81a\n\xBCV[\x93P` \x85\x015\x92P`@\x85\x015a\x0B\x9C\x81a\n\xBCV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xB7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\x0B\xC7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xE1Wa\x0B\xE1a\n\xE0V[a\x0B\xF4` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0B6V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0C\x08W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0C=W__\xFD[\x855a\x0CH\x81a\n\xBCV[\x94P` \x86\x015\x93P`@\x86\x015a\x0C_\x81a\n\xBCV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0C\x90W__\xFD[Pa\x0C\x99a\x0B\rV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0C\xBEW__\xFD[Pa\x0C\xC7a\x0B\rV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C\xE1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\r 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[_` \x82\x84\x03\x12\x15a\r6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x08\xD0W__\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\xFE\xA2dipfsX\"\x12 \xD28\x8C\xB3\xDCz\xA6\xF5\xA2\xEBuA}\x11\x05\x9B\xE1<\x8C\x9E\xAB\xE5\xD7\xEA\xDB\x1BV\x1F\x93\x7F\xF6\x91dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\x1E8\x03\x80a\r\x1E\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CHa\0\xD6_9_\x81\x81`S\x01R\x81\x81a\x01U\x01Ra\x02\x89\x01R_\x81\x81`\xA3\x01R\x81\x81a\x01\xC1\x01R\x81\x81a\x03(\x01Ra\x04b\x01Ra\x0CH_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x16\xF0\x11[\x14a\0NW\x80c%\xE2\xD6%\x14a\0\x9EW\x80cPcL\x0E\x14a\0\xC5W\x80c\x7F\x81O5\x14a\0\xDAW[__\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\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[a\0\xD8a\0\xD36`\x04a\t\xCEV[a\0\xEDV[\0[a\0\xD8a\0\xE86`\x04a\n\x90V[a\x01\x17V[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x14V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xBFV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x83V[`@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\x83\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B8V[`@Q\x7Fa{\xA07\0\0\0\0\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`$\x82\x01\x87\x90R\x85\x81\x16`D\x83\x01R_`d\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\x90ca{\xA07\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\xCCW__\xFD[PZ\xF1\x15\x80\x15a\x02\xDEW=__>=_\xFD[PP`@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\x86\x81\x16`\x04\x83\x01R_\x93P\x7F\0\0\0\0\0\0\0\0\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\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03nW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x92\x91\x90a\x0B8V[\x90P\x81\x81\x11a\x03\xE8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x03\xF3\x83\x83a\x0B|V[\x84Q\x90\x91P\x81\x10\x15a\x04GW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xDFV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05}\x90\x85\x90\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\x90`\x84\x01[`@\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~V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1B\x91\x90a\x0B8V[a\x06%\x91\x90a\x0B\x95V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05}\x90\x85\x90\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\x90`d\x01a\x05\x19V[_a\x06\xDF\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\x07t\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07oW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFD\x91\x90a\x0B\xA8V[a\x07oW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[PPPV[``a\x07\x82\x84\x84_\x85a\x07\x8CV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\x04W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08hW`@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\x03\xDFV[__\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\x08\x90\x91\x90a\x0B\xC7V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xCAW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xCFV[``\x91P[P\x91P\x91Pa\x08\xDF\x82\x82\x86a\x08\xEAV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xF9WP\x81a\x07\x85V[\x82Q\x15a\t\tW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xDF\x91\x90a\x0B\xDDV[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\tDW__\xFD[PV[\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\x97Wa\t\x97a\tGV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC6Wa\t\xC6a\tGV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE1W__\xFD[\x845a\t\xEC\x81a\t#V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x03\x81a\t#V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x1EW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n.W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nHWa\nHa\tGV[a\n[` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9DV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\noW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA4W__\xFD[\x855a\n\xAF\x81a\t#V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC6\x81a\t#V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF7W__\xFD[Pa\x0B\0a\ttV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B%W__\xFD[Pa\x0B.a\ttV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BHW__\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[\x81\x81\x03\x81\x81\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[_` \x82\x84\x03\x12\x15a\x0B\xB8W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x85W__\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\xFE\xA2dipfsX\"\x12 \x82\xCFY\x81d\x94k\x8Fq\x9CM\x82\xEF^\xF6\x0E=\xDAW\xBE\xC7=\xE3\xE8\x87\xB6ny\x0B\xF7WqdsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r 8\x03\x80a\r \x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CJa\0\xD6_9_\x81\x81`S\x01R\x81\x81a\x03u\x01Ra\x03\xF5\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0CJ_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cF\"l1\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xF2#L\xF9\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\t\xD0V[a\0\xEDV[\0[a\0\xB1a\0\xC16`\x04a\n\x92V[a\x01\x17V[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[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 \x0F\x90\x04\x05\x04;C\xAF,\x7Fu,\xFE\x8C\xA7\xFF\xD73Q\x1A\x05>\x1A>\x8A\xD4\xB3\0\x13\x98\0$dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 g\xE5\xF4yU\x0BP|6\xA4MB`\x91\xFD\x98\xCFh\xAD\xE8lC\xBEx<\xDD\xDE\x02\xE0~\xF3(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\0\xFBW_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\x93W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x01\xBBW\x80c\xF9\xCE\x0EZ\x14a\x01\xC3W\x80c\xFAv&\xD4\x14a\x01\xD6W\x80c\xFC\x0CTj\x14a\x01\xE3W__\xFD[\x80c\x91j\x17\xC6\x14a\x01~W\x80c\xB0FO\xDC\x14a\x01\x93W\x80c\xB5P\x8A\xA9\x14a\x01\x9BW\x80c\xBAAO\xA6\x14a\x01\xA3W__\xFD[\x80c?r\x86\xF4\x11a\0\xCEW\x80c?r\x86\xF4\x14a\x01DW\x80cB\xB0\x1C\xFE\x14a\x01LW\x80cf\xD9\xA9\xA0\x14a\x01TW\x80c\x85\"l\x81\x14a\x01iW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x1E\xD7\x83\x1C\x14a\x01\tW\x80c*\xDE8\x80\x14a\x01'W\x80c>^<#\x14a\x01*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x10\xA7V[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\0W\x83\x82\x90_R` _ \x01\x80Ta\x03u\x90a\x17?V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xA1\x90a\x17?V[\x80\x15a\x03\xECW\x80`\x1F\x10a\x03\xC3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xECV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xCFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03XV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xFAV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[_sT\x1F\xD7IA\x9C\xA8\x06\xA8\xBC}\xA8\xAC#\xD3F\xF2\xDF\x8Bw\x90P_s\xCC\tf\xD8A\x8DA,Y\x9Ad!\xB7`\xA8G\xEB\x16\x9A\x8C\x90P_sI\xB0r\x15\x85d\xDB60E\x18\xFF\xA3{\x1C\xFC\x13\x91j\x90s\xBAF\xFC\xC1kFM\x97\x871Ag\xBD\xD9\xF1\xCE(@[\xA1\x7FVdR\x02@\xA4kK>\x96U\xC2\x0C\xC3\xF9\xE0\x84\x96\xA9\xB7F\xA4x\xE4v\xAE>\x04\xD6\xC8\xFC1\x7Fh\x99\xA7\xE1;e_\xA3g \x8C\xB2|n\xAA$\x107\r\x15e\xDC\x1F_\x11\x85:\x1E\x8C\xBE\xF03\x86\x86`@Qa\x05\xA1\x90a\x13\x80V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x96\x87\x16\x81R\x94\x86\x16` \x86\x01R`@\x85\x01\x93\x90\x93R``\x84\x01\x91\x90\x91R\x83\x16`\x80\x83\x01R\x90\x91\x16`\xA0\x82\x01R`\xC0\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x05\xFEW=__>=_\xFD[P\x90P_s.e\0\xA7\xAD\xD9\xA7\x88u:\x89~N4w\xF6Q\xC6\x12\xEB\x90P_s5\xB3\xF1\xBF\xE7\xCB\xE1\xE9Z=\xC2\xAD\x05N\xB6\xF0\xD4\xC8y\xB6\x90P_\x82\x82`@Qa\x06@\x90a\x13\x8DV[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x06}W=__>=_\xFD[P\x90P_\x84\x82`@Qa\x06\x8F\x90a\x13\x9AV[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x06\xCCW=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07FW__\xFD[PZ\xF1\x15\x80\x15a\x07XW=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x07\xDBW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xFF\x91\x90a\x17\x90V[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\x81R`\x01`\x04\x82\x01Ra\x08\x97\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\x08mW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\x91\x91\x90a\x17\xB6V[_a\x12\xFDV[`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t*W__\xFD[PZ\xF1\x15\x80\x15a\t=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t\x99W__\xFD[PZ\xF1\x15\x80\x15a\t\xABW=__>=_\xFD[PP`@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\x81R`\x01`\x04\x82\x01Ra\nN\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\n\x1CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n@\x91\x90a\x17\xB6V[g\r\xE0\xB6\xB3\xA7d\0\0a\x12\xFDV[PPPPPPPV[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\n\xAA\x90a\x17?V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n\xD6\x90a\x17?V[\x80\x15a\x0B!W\x80`\x1F\x10a\n\xF8Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B!V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\x04W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x0B\xB8W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0BeW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\nzV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\x0C\x10\x90a\x17?V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C<\x90a\x17?V[\x80\x15a\x0C\x87W\x80`\x1F\x10a\x0C^Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C\x87V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0CjW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0B\xF3V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\x86W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r3W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xBEV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0E\x89W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0E6W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\r\xC1V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\x0E\xE1\x90a\x17?V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F\r\x90a\x17?V[\x80\x15a\x0FXW\x80`\x1F\x10a\x0F/Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0FXV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F;W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0E\xC4V[`\x08T_\x90`\xFF\x16\x15a\x0F\x83WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\x11W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x105\x91\x90a\x17\xB6V[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11BW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x11i\x91\x90\x81\x01\x90a\x17\xFAV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x11\x87\x92\x91\x90a\x18\xAEV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11\xA3W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\xC7\x91\x90a\x17\xB6V[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12@W__\xFD[PZ\xF1\x15\x80\x15a\x12RW=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x12\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xF6\x91\x90a\x17\x90V[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x13fW__\xFD[PZ\xFA\x15\x80\x15a\x13xW=__>=_\xFD[PPPPPPV[a\x0F-\x80a\x18\xD0\x839\x01\x90V[a\r\x1E\x80a'\xFD\x839\x01\x90V[a\r \x80a5\x1B\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x13\xF4W\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\x13\xC0V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x15W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x14\xFBW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x14\xE5\x84\x86Qa\x13\xFFV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x14\xABV[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x14SV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x15sW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x153V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x15W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x15\xC9`@\x88\x01\x82a\x13\xFFV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x15\xE4\x81\x83a\x15!V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\xA3V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x15W`?\x19\x87\x86\x03\x01\x84Ra\x16=\x85\x83Qa\x13\xFFV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16!V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x15W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x16\xC0`@\x87\x01\x82a\x15!V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16xV[\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\x16\xF9W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x17\x11W__\xFD[\x845\x93Pa\x17!` \x86\x01a\x16\xD6V[\x92Pa\x17/`@\x86\x01a\x16\xD6V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x17SW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x17\x8AW\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17\xA0W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x17\xAFW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x17\xC6W__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x18\nW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18 W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x180W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18JWa\x18Ja\x17\xCDV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x18zWa\x18za\x17\xCDV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x18\x91W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x18\xC0`@\x83\x01\x85a\x13\xFFV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFEa\x01@`@R4\x80\x15a\0\x10W__\xFD[P`@Qa\x0F-8\x03\x80a\x0F-\x839\x81\x01`@\x81\x90Ra\0/\x91a\0sV[`\x01`\x01`\xA0\x1B\x03\x95\x86\x16`\x80R\x93\x85\x16`\xA0R`\xC0\x92\x90\x92R`\xE0R\x82\x16a\x01\0R\x16a\x01 Ra\0\xE3V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0pW__\xFD[PV[______`\xC0\x87\x89\x03\x12\x15a\0\x88W__\xFD[\x86Qa\0\x93\x81a\0\\V[` \x88\x01Q\x90\x96Pa\0\xA4\x81a\0\\V[`@\x88\x01Q``\x89\x01Q`\x80\x8A\x01Q\x92\x97P\x90\x95P\x93Pa\0\xC4\x81a\0\\V[`\xA0\x88\x01Q\x90\x92Pa\0\xD5\x81a\0\\V[\x80\x91PP\x92\x95P\x92\x95P\x92\x95V[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\r\xC6a\x01g_9_\x81\x81a\x01.\x01R\x81\x81a\x04\xFC\x01Ra\x05>\x01R_\x81\x81a\x01U\x01Ra\x03R\x01R_\x81\x81a\x01\xB1\x01Ra\x03\xC1\x01R_\x81\x81a\x01|\x01Ra\x02\x88\x01R_\x81\x81`\xDF\x01R\x81\x81a\x03t\x01Ra\x03\xF0\x01R_\x81\x81`\x8E\x01R\x81\x81a\x02;\x01Ra\x02\xB7\x01Ra\r\xC6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\x85W_5`\xE0\x1C\x80c\xADt}\xE6\x11a\0XW\x80c\xADt}\xE6\x14a\x01)W\x80c\xB9\x93|\xCB\x14a\x01PW\x80c\xC8\xC7\xF7\x01\x14a\x01wW\x80c\xE3L\xEF\x86\x14a\x01\xACW__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0\x89W\x80cN=\xF3\xF4\x14a\0\xDAW\x80cPcL\x0E\x14a\x01\x01W\x80c\x7F\x81O5\x14a\x01\x16W[__\xFD[a\0\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\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\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\x81V[a\x01\x14a\x01\x0F6`\x04a\x0BgV[a\x01\xD3V[\0[a\x01\x14a\x01$6`\x04a\x0C)V[a\x01\xFDV[a\0\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\x81V[a\0\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\x81V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xD1V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\xE8\x91\x90a\x0C\xADV[\x90Pa\x01\xF6\x85\x85\x85\x84a\x01\xFDV[PPPPPV[a\x02\x1Fs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x9AV[a\x02`s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x036\x91\x90a\x0C\xD1V[\x90Pa\x03\x99s\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\x7F\0\0\0\0\0\0\0\0\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\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x82\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04KW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04o\x91\x90a\x0C\xD1V[\x83Q\x90\x91P\x81\x10\x15a\x04\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[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\x85\x83a\x07YV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x06X\x90\x85\x90\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\x90`\x84\x01[`@\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\x07\xB4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF6\x91\x90a\x0C\xD1V[a\x07\0\x91\x90a\x0C\xE8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x06X\x90\x85\x90\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\x90`d\x01a\x05\xF4V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07\xAF\x90\x84\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\x90`d\x01a\x05\xF4V[PPPV[_a\x08\x15\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\x08\xBF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\xAFW\x80\x80` \x01\x90Q\x81\x01\x90a\x083\x91\x90a\r&V[a\x07\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\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\x04\xD9V[``a\x08\xCD\x84\x84_\x85a\x08\xD7V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\tiW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x04\xD9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\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`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x04\xD9V[__\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\n\x0F\x91\x90a\rEV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\nIW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\nNV[``\x91P[P\x91P\x91Pa\n^\x82\x82\x86a\niV[\x97\x96PPPPPPPV[``\x83\x15a\nxWP\x81a\x08\xD0V[\x82Q\x15a\n\x88W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x04\xD9\x91\x90a\r[V[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\xDDW__\xFD[PV[\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\x0B0Wa\x0B0a\n\xE0V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0B_Wa\x0B_a\n\xE0V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0BzW__\xFD[\x845a\x0B\x85\x81a\n\xBCV[\x93P` \x85\x015\x92P`@\x85\x015a\x0B\x9C\x81a\n\xBCV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xB7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\x0B\xC7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xE1Wa\x0B\xE1a\n\xE0V[a\x0B\xF4` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0B6V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0C\x08W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0C=W__\xFD[\x855a\x0CH\x81a\n\xBCV[\x94P` \x86\x015\x93P`@\x86\x015a\x0C_\x81a\n\xBCV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0C\x90W__\xFD[Pa\x0C\x99a\x0B\rV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0C\xBEW__\xFD[Pa\x0C\xC7a\x0B\rV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C\xE1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\r 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[_` \x82\x84\x03\x12\x15a\r6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x08\xD0W__\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\xFE\xA2dipfsX\"\x12 \xD28\x8C\xB3\xDCz\xA6\xF5\xA2\xEBuA}\x11\x05\x9B\xE1<\x8C\x9E\xAB\xE5\xD7\xEA\xDB\x1BV\x1F\x93\x7F\xF6\x91dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\x1E8\x03\x80a\r\x1E\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CHa\0\xD6_9_\x81\x81`S\x01R\x81\x81a\x01U\x01Ra\x02\x89\x01R_\x81\x81`\xA3\x01R\x81\x81a\x01\xC1\x01R\x81\x81a\x03(\x01Ra\x04b\x01Ra\x0CH_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x16\xF0\x11[\x14a\0NW\x80c%\xE2\xD6%\x14a\0\x9EW\x80cPcL\x0E\x14a\0\xC5W\x80c\x7F\x81O5\x14a\0\xDAW[__\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\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[a\0\xD8a\0\xD36`\x04a\t\xCEV[a\0\xEDV[\0[a\0\xD8a\0\xE86`\x04a\n\x90V[a\x01\x17V[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x14V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xBFV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x83V[`@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\x83\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B8V[`@Q\x7Fa{\xA07\0\0\0\0\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`$\x82\x01\x87\x90R\x85\x81\x16`D\x83\x01R_`d\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\x90ca{\xA07\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\xCCW__\xFD[PZ\xF1\x15\x80\x15a\x02\xDEW=__>=_\xFD[PP`@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\x86\x81\x16`\x04\x83\x01R_\x93P\x7F\0\0\0\0\0\0\0\0\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\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03nW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x92\x91\x90a\x0B8V[\x90P\x81\x81\x11a\x03\xE8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x03\xF3\x83\x83a\x0B|V[\x84Q\x90\x91P\x81\x10\x15a\x04GW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xDFV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05}\x90\x85\x90\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\x90`\x84\x01[`@\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~V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1B\x91\x90a\x0B8V[a\x06%\x91\x90a\x0B\x95V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05}\x90\x85\x90\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\x90`d\x01a\x05\x19V[_a\x06\xDF\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\x07t\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07oW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFD\x91\x90a\x0B\xA8V[a\x07oW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[PPPV[``a\x07\x82\x84\x84_\x85a\x07\x8CV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\x04W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xDFV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08hW`@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\x03\xDFV[__\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\x08\x90\x91\x90a\x0B\xC7V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xCAW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xCFV[``\x91P[P\x91P\x91Pa\x08\xDF\x82\x82\x86a\x08\xEAV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xF9WP\x81a\x07\x85V[\x82Q\x15a\t\tW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xDF\x91\x90a\x0B\xDDV[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\tDW__\xFD[PV[\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\x97Wa\t\x97a\tGV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC6Wa\t\xC6a\tGV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE1W__\xFD[\x845a\t\xEC\x81a\t#V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x03\x81a\t#V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x1EW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n.W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nHWa\nHa\tGV[a\n[` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9DV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\noW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA4W__\xFD[\x855a\n\xAF\x81a\t#V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC6\x81a\t#V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF7W__\xFD[Pa\x0B\0a\ttV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B%W__\xFD[Pa\x0B.a\ttV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BHW__\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[\x81\x81\x03\x81\x81\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0B\x8FWa\x0B\x8Fa\x0BOV[_` \x82\x84\x03\x12\x15a\x0B\xB8W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x85W__\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\xFE\xA2dipfsX\"\x12 \x82\xCFY\x81d\x94k\x8Fq\x9CM\x82\xEF^\xF6\x0E=\xDAW\xBE\xC7=\xE3\xE8\x87\xB6ny\x0B\xF7WqdsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r 8\x03\x80a\r \x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CJa\0\xD6_9_\x81\x81`S\x01R\x81\x81a\x03u\x01Ra\x03\xF5\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0CJ_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cF\"l1\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xF2#L\xF9\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\t\xD0V[a\0\xEDV[\0[a\0\xB1a\0\xC16`\x04a\n\x92V[a\x01\x17V[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[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 \x0F\x90\x04\x05\x04;C\xAF,\x7Fu,\xFE\x8C\xA7\xFF\xD73Q\x1A\x05>\x1A>\x8A\xD4\xB3\0\x13\x98\0$dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 g\xE5\xF4yU\x0BP|6\xA4MB`\x91\xFD\x98\xCFh\xAD\xE8lC\xBEx<\xDD\xDE\x02\xE0~\xF3(dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. -```solidity -event log(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `setUp()` and selector `0x0a9254e4`. -```solidity -function setUp() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setUpCall; - ///Container type for the return parameters of the [`setUp()`](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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl setUpReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for setUpCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = setUpReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "setUp()"; - const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - setUpReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. -```solidity -function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferCall { - #[allow(missing_docs)] - pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub sender: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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::Uint<256>, - ); - #[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::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferCall) -> Self { - (value.forkAtBlock, value.sender, value.receiver, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - forkAtBlock: tuple.0, - sender: tuple.1, - receiver: tuple.2, - amount: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl simulateForkAndTransferReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for simulateForkAndTransferCall { - type Parameters<'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::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = simulateForkAndTransferReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; - const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), - ::tokenize( - &self.sender, - ), - ::tokenize( - &self.receiver, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - simulateForkAndTransferReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testWbtcLstStrategy()` and selector `0x42b01cfe`. -```solidity -function testWbtcLstStrategy() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testWbtcLstStrategyCall; - ///Container type for the return parameters of the [`testWbtcLstStrategy()`](testWbtcLstStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testWbtcLstStrategyReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testWbtcLstStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testWbtcLstStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testWbtcLstStrategyReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testWbtcLstStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testWbtcLstStrategyReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testWbtcLstStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testWbtcLstStrategyReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testWbtcLstStrategy()"; - const SELECTOR: [u8; 4] = [66u8, 176u8, 28u8, 254u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testWbtcLstStrategyReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `token()` and selector `0xfc0c546a`. -```solidity -function token() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`token()`](tokenCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for tokenCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "token()"; - const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`AvalonWBTCLstStrategyForked`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum AvalonWBTCLstStrategyForkedCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - setUp(setUpCall), - #[allow(missing_docs)] - simulateForkAndTransfer(simulateForkAndTransferCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - testWbtcLstStrategy(testWbtcLstStrategyCall), - #[allow(missing_docs)] - token(tokenCall), - } - #[automatically_derived] - impl AvalonWBTCLstStrategyForkedCalls { - /// 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]] = &[ - [10u8, 146u8, 84u8, 228u8], - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [66u8, 176u8, 28u8, 254u8], - [102u8, 217u8, 169u8, 160u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [226u8, 12u8, 159u8, 113u8], - [249u8, 206u8, 14u8, 90u8], - [250u8, 118u8, 38u8, 212u8], - [252u8, 12u8, 84u8, 106u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for AvalonWBTCLstStrategyForkedCalls { - const NAME: &'static str = "AvalonWBTCLstStrategyForkedCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 16usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::setUp(_) => ::SELECTOR, - Self::simulateForkAndTransfer(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::testWbtcLstStrategy(_) => { - ::SELECTOR - } - Self::token(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(AvalonWBTCLstStrategyForkedCalls::setUp) - } - setUp - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::targetContracts) - } - targetContracts - }, - { - fn testWbtcLstStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::testWbtcLstStrategy) - } - testWbtcLstStrategy - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - AvalonWBTCLstStrategyForkedCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(AvalonWBTCLstStrategyForkedCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - AvalonWBTCLstStrategyForkedCalls::simulateForkAndTransfer, - ) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(AvalonWBTCLstStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(AvalonWBTCLstStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::setUp) - } - setUp - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::targetContracts) - } - targetContracts - }, - { - fn testWbtcLstStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::testWbtcLstStrategy) - } - testWbtcLstStrategy - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - AvalonWBTCLstStrategyForkedCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - AvalonWBTCLstStrategyForkedCalls::simulateForkAndTransfer, - ) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(AvalonWBTCLstStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::setUp(inner) => { - ::abi_encoded_size(inner) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testWbtcLstStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::token(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::setUp(inner) => { - ::abi_encode_raw(inner, out) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testWbtcLstStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::token(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - ///Container for all the [`AvalonWBTCLstStrategyForked`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum AvalonWBTCLstStrategyForkedEvents { - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl AvalonWBTCLstStrategyForkedEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for AvalonWBTCLstStrategyForkedEvents { - const NAME: &'static str = "AvalonWBTCLstStrategyForkedEvents"; - const COUNT: usize = 22usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 AvalonWBTCLstStrategyForkedEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`AvalonWBTCLstStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`AvalonWBTCLstStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> AvalonWBTCLstStrategyForkedInstance { - AvalonWBTCLstStrategyForkedInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - AvalonWBTCLstStrategyForkedInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - AvalonWBTCLstStrategyForkedInstance::::deploy_builder(provider) - } - /**A [`AvalonWBTCLstStrategyForked`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`AvalonWBTCLstStrategyForked`](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 AvalonWBTCLstStrategyForkedInstance< - P, - N = alloy_contract::private::Ethereum, - > { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for AvalonWBTCLstStrategyForkedInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("AvalonWBTCLstStrategyForkedInstance") - .field(&self.address) - .finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > AvalonWBTCLstStrategyForkedInstance { - /**Creates a new wrapper around an on-chain [`AvalonWBTCLstStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`AvalonWBTCLstStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 AvalonWBTCLstStrategyForkedInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> AvalonWBTCLstStrategyForkedInstance { - AvalonWBTCLstStrategyForkedInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > AvalonWBTCLstStrategyForkedInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`setUp`] function. - pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { - self.call_builder(&setUpCall) - } - ///Creates a new call builder for the [`simulateForkAndTransfer`] function. - pub fn simulateForkAndTransfer( - &self, - forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - sender: alloy::sol_types::private::Address, - receiver: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { - self.call_builder( - &simulateForkAndTransferCall { - forkAtBlock, - sender, - receiver, - amount, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`testWbtcLstStrategy`] function. - pub fn testWbtcLstStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testWbtcLstStrategyCall, N> { - self.call_builder(&testWbtcLstStrategyCall) - } - ///Creates a new call builder for the [`token`] function. - pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { - self.call_builder(&tokenCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > AvalonWBTCLstStrategyForkedInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/bedrock_strategy.rs b/crates/bindings/src/bedrock_strategy.rs deleted file mode 100644 index 34d69d8fc..000000000 --- a/crates/bindings/src/bedrock_strategy.rs +++ /dev/null @@ -1,1554 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface BedrockStrategy { - struct StrategySlippageArgs { - uint256 amountOutMin; - } - - event TokenOutput(address tokenReceived, uint256 amountOut); - - constructor(address _vault); - - function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; - function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; - function vault() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "_vault", - "type": "address", - "internalType": "contract IBedrockVault" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessage", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "message", - "type": "bytes", - "internalType": "bytes" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessageWithSlippageArgs", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "args", - "type": "tuple", - "internalType": "struct StrategySlippageArgs", - "components": [ - { - "name": "amountOutMin", - "type": "uint256", - "internalType": "uint256" - } - ] - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "vault", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IBedrockVault" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "TokenOutput", - "inputs": [ - { - "name": "tokenReceived", - "type": "address", - "indexed": false, - "internalType": "address" - }, - { - "name": "amountOut", - "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 BedrockStrategy { - use super::*; - use alloy::sol_types as 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__\xFD[P`@Qa\x0C\xD48\x03\x80a\x0C\xD4\x839\x81\x01`@\x81\x90Ra\0.\x91a\0?V[`\x01`\x01`\xA0\x1B\x03\x16`\x80Ra\0lV[_` \x82\x84\x03\x12\x15a\0OW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0eW__\xFD[\x93\x92PPPV[`\x80Qa\x0C=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02UW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02y\x91\x90a\x0B,V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xE6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\n\x91\x90a\x0BGV[\x83Q\x90\x91P\x81\x10\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\x9Es\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x85\x83a\x05\xB4V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xB3\x90\x85\x90\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\x90`\x84\x01[`@\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\x0FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05-W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05Q\x91\x90a\x0BGV[a\x05[\x91\x90a\x0B^V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xB3\x90\x85\x90\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\x90`d\x01a\x04OV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x06\n\x90\x84\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\x90`d\x01a\x04OV[PPPV[_a\x06p\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\x07\x1A\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\nW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x8E\x91\x90a\x0B\x9CV[a\x06\nW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[``a\x07(\x84\x84_\x85a\x072V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xC4W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08BW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[__\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\x08j\x91\x90a\x0B\xBBV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xA4W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xA9V[``\x91P[P\x91P\x91Pa\x08\xB9\x82\x82\x86a\x08\xC4V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xD3WP\x81a\x07+V[\x82Q\x15a\x08\xE3W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03t\x91\x90a\x0B\xD1V[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\t8W__\xFD[PV[\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\x8BWa\t\x8Ba\t;V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xBAWa\t\xBAa\t;V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xD5W__\xFD[\x845a\t\xE0\x81a\t\x17V[\x93P` \x85\x015\x92P`@\x85\x015a\t\xF7\x81a\t\x17V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x12W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\"W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nz9,\xA4\xD4K\x0C\x1B\x8D=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02UW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02y\x91\x90a\x0B,V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xE6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\n\x91\x90a\x0BGV[\x83Q\x90\x91P\x81\x10\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\x9Es\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x85\x83a\x05\xB4V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xB3\x90\x85\x90\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\x90`\x84\x01[`@\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\x0FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05-W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05Q\x91\x90a\x0BGV[a\x05[\x91\x90a\x0B^V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xB3\x90\x85\x90\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\x90`d\x01a\x04OV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x06\n\x90\x84\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\x90`d\x01a\x04OV[PPPV[_a\x06p\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\x07\x1A\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\nW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x8E\x91\x90a\x0B\x9CV[a\x06\nW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[``a\x07(\x84\x84_\x85a\x072V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xC4W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08BW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[__\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\x08j\x91\x90a\x0B\xBBV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xA4W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xA9V[``\x91P[P\x91P\x91Pa\x08\xB9\x82\x82\x86a\x08\xC4V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xD3WP\x81a\x07+V[\x82Q\x15a\x08\xE3W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03t\x91\x90a\x0B\xD1V[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\t8W__\xFD[PV[\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\x8BWa\t\x8Ba\t;V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xBAWa\t\xBAa\t;V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xD5W__\xFD[\x845a\t\xE0\x81a\t\x17V[\x93P` \x85\x015\x92P`@\x85\x015a\t\xF7\x81a\t\x17V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x12W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\"W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nz9,\xA4\xD4K\x0C\x1B\x8D = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: StrategySlippageArgs) -> Self { - (value.amountOutMin,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for StrategySlippageArgs { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { amountOutMin: tuple.0 } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for StrategySlippageArgs { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for StrategySlippageArgs { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for StrategySlippageArgs { - const NAME: &'static str = "StrategySlippageArgs"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "StrategySlippageArgs(uint256 amountOutMin)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) - .0 - .to_vec() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for StrategySlippageArgs { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.amountOutMin, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.amountOutMin, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. -```solidity -event TokenOutput(address tokenReceived, uint256 amountOut); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct TokenOutput { - #[allow(missing_docs)] - pub tokenReceived: alloy::sol_types::private::Address, - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for TokenOutput { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - tokenReceived: data.0, - amountOut: data.1, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.tokenReceived, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountOut), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 TokenOutput { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&TokenOutput> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &TokenOutput) -> 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value._vault,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._vault, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. -```solidity -function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub message: alloy::sol_types::private::Bytes, - } - ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ); - #[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, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.message) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - message: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageCall { - 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, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; - const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.message, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. -```solidity -function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub args: ::RustType, - } - ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::primitives::aliases::U256, - alloy::sol_types::private::Address, - ::RustType, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.args) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - args: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageWithSlippageArgsReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageWithSlippageArgsReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; - const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.args, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: vaultCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for vaultCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: vaultReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for vaultReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for vaultCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "vault()"; - const SELECTOR: [u8; 4] = [251u8, 250u8, 119u8, 207u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: vaultReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`BedrockStrategy`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum BedrockStrategyCalls { - #[allow(missing_docs)] - handleGatewayMessage(handleGatewayMessageCall), - #[allow(missing_docs)] - handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), - #[allow(missing_docs)] - vault(vaultCall), - } - #[automatically_derived] - impl BedrockStrategyCalls { - /// 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, 99u8, 76u8, 14u8], - [127u8, 129u8, 79u8, 53u8], - [251u8, 250u8, 119u8, 207u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for BedrockStrategyCalls { - const NAME: &'static str = "BedrockStrategyCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 3usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::handleGatewayMessage(_) => { - ::SELECTOR - } - Self::handleGatewayMessageWithSlippageArgs(_) => { - ::SELECTOR - } - Self::vault(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BedrockStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - BedrockStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - { - fn vault( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(BedrockStrategyCalls::vault) - } - vault - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BedrockStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - BedrockStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - { - fn vault( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BedrockStrategyCalls::vault) - } - vault - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::handleGatewayMessage(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::vault(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::handleGatewayMessage(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::vault(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - ///Container for all the [`BedrockStrategy`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum BedrockStrategyEvents { - #[allow(missing_docs)] - TokenOutput(TokenOutput), - } - #[automatically_derived] - impl BedrockStrategyEvents { - /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for BedrockStrategyEvents { - const NAME: &'static str = "BedrockStrategyEvents"; - const COUNT: usize = 1usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::TokenOutput) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 BedrockStrategyEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`BedrockStrategy`](self) contract instance. - -See the [wrapper's documentation](`BedrockStrategyInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> BedrockStrategyInstance { - BedrockStrategyInstance::::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: alloy_contract::private::Network, - >( - provider: P, - _vault: alloy::sol_types::private::Address, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - BedrockStrategyInstance::::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: alloy_contract::private::Network, - >( - provider: P, - _vault: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - BedrockStrategyInstance::::deploy_builder(provider, _vault) - } - /**A [`BedrockStrategy`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`BedrockStrategy`](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 BedrockStrategyInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for BedrockStrategyInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("BedrockStrategyInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BedrockStrategyInstance { - /**Creates a new wrapper around an on-chain [`BedrockStrategy`](self) contract instance. - -See the [wrapper's documentation](`BedrockStrategyInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 BedrockStrategyInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> BedrockStrategyInstance { - BedrockStrategyInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BedrockStrategyInstance { - /// 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( - &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 [`handleGatewayMessage`] function. - pub fn handleGatewayMessage( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - message: alloy::sol_types::private::Bytes, - ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { - self.call_builder( - &handleGatewayMessageCall { - tokenSent, - amountIn, - recipient, - message, - }, - ) - } - ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. - pub fn handleGatewayMessageWithSlippageArgs( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - args: ::RustType, - ) -> alloy_contract::SolCallBuilder< - &P, - handleGatewayMessageWithSlippageArgsCall, - N, - > { - self.call_builder( - &handleGatewayMessageWithSlippageArgsCall { - tokenSent, - amountIn, - recipient, - args, - }, - ) - } - ///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. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BedrockStrategyInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`TokenOutput`] event. - pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/bedrock_strategy_forked.rs b/crates/bindings/src/bedrock_strategy_forked.rs deleted file mode 100644 index 6f0498b39..000000000 --- a/crates/bindings/src/bedrock_strategy_forked.rs +++ /dev/null @@ -1,7991 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface BedrockStrategyForked { - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function setUp() external; - function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function testBedrockStrategy() external; - function token() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "setUp", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "simulateForkAndTransfer", - "inputs": [ - { - "name": "forkAtBlock", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "sender", - "type": "address", - "internalType": "address" - }, - { - "name": "receiver", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testBedrockStrategy", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "token", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IERC20" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 BedrockStrategyForked { - use super::*; - use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15`+W__\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16t\x03\xC7\x05K\xCB9\xF7\xB2\xE5\xB2\xC7\xAC\xB3u\x83\xE3-p\xCF\xA3\0\x17\x90Ua$\x91\x80a\0a_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xFBW_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\x93W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x01\xBBW\x80c\xF9\xCE\x0EZ\x14a\x01\xC3W\x80c\xFAv&\xD4\x14a\x01\xD6W\x80c\xFC\x0CTj\x14a\x01\xE3W__\xFD[\x80c\x91j\x17\xC6\x14a\x01~W\x80c\xB0FO\xDC\x14a\x01\x93W\x80c\xB5P\x8A\xA9\x14a\x01\x9BW\x80c\xBAAO\xA6\x14a\x01\xA3W__\xFD[\x80c>^<#\x11a\0\xCEW\x80c>^<#\x14a\x01DW\x80c?r\x86\xF4\x14a\x01LW\x80cf\xD9\xA9\xA0\x14a\x01TW\x80c\x85\"l\x81\x14a\x01iW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x1E\xD7\x83\x1C\x14a\x01\tW\x80c*\xDE8\x80\x14a\x01'W\x80c=\x81'\xE0\x14a\x01*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x0F5V[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\0W\x83\x82\x90_R` _ \x01\x80Ta\x03u\x90a\x15\xB5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xA1\x90a\x15\xB5V[\x80\x15a\x03\xECW\x80`\x1F\x10a\x03\xC3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xECV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xCFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03XV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xFAV[PPPP\x90P\x90V[_s*\xC9\x8D\xB4\x1C\xBD1r\xCB{\x8F\xD8\xA8\xAB;\x91\xCF\xE4]\xCF\x90P_\x81`@Qa\x04F\x90a\x12\x10V[s\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_\xF0\x80\x15\x80\x15a\x04|W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xF6W__\xFD[PZ\xF1\x15\x80\x15a\x05\x08W=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x05\x8BW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xAF\x91\x90a\x16\x06V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x06CW__\xFD[PZ\xF1\x15\x80\x15a\x06UW=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x06\xB2W__\xFD[PZ\xF1\x15\x80\x15a\x06\xC4W=__>=_\xFD[PPPP_\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x076\x91\x90a\x16,V[`@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\x81R`\x01`\x04\x82\x01R\x90\x91Pa\x08\n\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07\xA6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xCA\x91\x90a\x16GV[c\x05\xF5\xE1\0`@Q\x80`@\x01`@R\x80`\x1C\x81R` \x01\x7FUser uniBTC balance mismatch\0\0\0\0\x81RPa\x11\x8BV[PPPV[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\t8\x90a\x15\xB5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\td\x90a\x15\xB5V[\x80\x15a\t\xAFW\x80`\x1F\x10a\t\x86Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\t\xAFV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t\x92W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\nFW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\t\xF3W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\t\x08V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\n\x9E\x90a\x15\xB5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n\xCA\x90a\x15\xB5V[\x80\x15a\x0B\x15W\x80`\x1F\x10a\n\xECWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\x15V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\n\xF8W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\n\x81V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\x14W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0B\xC1W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0BLV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\x17W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C\xC4W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0COV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\ro\x90a\x15\xB5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\x9B\x90a\x15\xB5V[\x80\x15a\r\xE6W\x80`\x1F\x10a\r\xBDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\r\xE6V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r\xC9W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\rRV[`\x08T_\x90`\xFF\x16\x15a\x0E\x11WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\xC3\x91\x90a\x16GV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\xD0W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x0F\xF7\x91\x90\x81\x01\x90a\x16\x8BV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x10\x15\x92\x91\x90a\x17?V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x101W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10U\x91\x90a\x16GV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10\xCEW__\xFD[PZ\xF1\x15\x80\x15a\x10\xE0W=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11`W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\x84\x91\x90a\x16\x06V[PPPPPV[`@Q\x7F\x88\xB4L\x85\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x88\xB4L\x85\x90a\x11\xDF\x90\x86\x90\x86\x90\x86\x90`\x04\x01a\x17`V[_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x11\xF5W__\xFD[PZ\xFA\x15\x80\x15a\x12\x07W=__>=_\xFD[PPPPPPPV[a\x0C\xD4\x80a\x17\x88\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x12jW\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\x126V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x8BW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x13qW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x13[\x84\x86Qa\x12uV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x13!V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x12\xC9V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x13\xE9W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x13\xA9V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x8BW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x14?`@\x88\x01\x82a\x12uV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x14Z\x81\x83a\x13\x97V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\x19V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x8BW`?\x19\x87\x86\x03\x01\x84Ra\x14\xB3\x85\x83Qa\x12uV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\x97V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x8BW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x156`@\x87\x01\x82a\x13\x97V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\xEEV[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\x15mW__\xFD[PV[____`\x80\x85\x87\x03\x12\x15a\x15\x83W__\xFD[\x845\x93P` \x85\x015a\x15\x95\x81a\x15LV[\x92P`@\x85\x015a\x15\xA5\x81a\x15LV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x15\xC9W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x16\0W\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x16\x16W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x16%W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x16=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02UW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02y\x91\x90a\x0B,V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xE6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\n\x91\x90a\x0BGV[\x83Q\x90\x91P\x81\x10\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\x9Es\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x85\x83a\x05\xB4V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xB3\x90\x85\x90\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\x90`\x84\x01[`@\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\x0FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05-W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05Q\x91\x90a\x0BGV[a\x05[\x91\x90a\x0B^V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xB3\x90\x85\x90\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\x90`d\x01a\x04OV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x06\n\x90\x84\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\x90`d\x01a\x04OV[PPPV[_a\x06p\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\x07\x1A\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\nW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x8E\x91\x90a\x0B\x9CV[a\x06\nW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[``a\x07(\x84\x84_\x85a\x072V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xC4W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08BW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[__\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\x08j\x91\x90a\x0B\xBBV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xA4W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xA9V[``\x91P[P\x91P\x91Pa\x08\xB9\x82\x82\x86a\x08\xC4V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xD3WP\x81a\x07+V[\x82Q\x15a\x08\xE3W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03t\x91\x90a\x0B\xD1V[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\t8W__\xFD[PV[\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\x8BWa\t\x8Ba\t;V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xBAWa\t\xBAa\t;V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xD5W__\xFD[\x845a\t\xE0\x81a\t\x17V[\x93P` \x85\x015\x92P`@\x85\x015a\t\xF7\x81a\t\x17V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x12W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\"W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nz9,\xA4\xD4K\x0C\x1B\x8D^<#\x11a\0\xCEW\x80c>^<#\x14a\x01DW\x80c?r\x86\xF4\x14a\x01LW\x80cf\xD9\xA9\xA0\x14a\x01TW\x80c\x85\"l\x81\x14a\x01iW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x1E\xD7\x83\x1C\x14a\x01\tW\x80c*\xDE8\x80\x14a\x01'W\x80c=\x81'\xE0\x14a\x01*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x0F5V[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\0W\x83\x82\x90_R` _ \x01\x80Ta\x03u\x90a\x15\xB5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xA1\x90a\x15\xB5V[\x80\x15a\x03\xECW\x80`\x1F\x10a\x03\xC3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xECV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xCFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03XV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xFAV[PPPP\x90P\x90V[_s*\xC9\x8D\xB4\x1C\xBD1r\xCB{\x8F\xD8\xA8\xAB;\x91\xCF\xE4]\xCF\x90P_\x81`@Qa\x04F\x90a\x12\x10V[s\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_\xF0\x80\x15\x80\x15a\x04|W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xF6W__\xFD[PZ\xF1\x15\x80\x15a\x05\x08W=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x05\x8BW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xAF\x91\x90a\x16\x06V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x06CW__\xFD[PZ\xF1\x15\x80\x15a\x06UW=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x06\xB2W__\xFD[PZ\xF1\x15\x80\x15a\x06\xC4W=__>=_\xFD[PPPP_\x82s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x076\x91\x90a\x16,V[`@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\x81R`\x01`\x04\x82\x01R\x90\x91Pa\x08\n\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07\xA6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xCA\x91\x90a\x16GV[c\x05\xF5\xE1\0`@Q\x80`@\x01`@R\x80`\x1C\x81R` \x01\x7FUser uniBTC balance mismatch\0\0\0\0\x81RPa\x11\x8BV[PPPV[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\t8\x90a\x15\xB5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\td\x90a\x15\xB5V[\x80\x15a\t\xAFW\x80`\x1F\x10a\t\x86Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\t\xAFV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t\x92W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\nFW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\t\xF3W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\t\x08V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\n\x9E\x90a\x15\xB5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n\xCA\x90a\x15\xB5V[\x80\x15a\x0B\x15W\x80`\x1F\x10a\n\xECWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\x15V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\n\xF8W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\n\x81V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\x14W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0B\xC1W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0BLV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\x17W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C\xC4W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0COV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\ro\x90a\x15\xB5V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\x9B\x90a\x15\xB5V[\x80\x15a\r\xE6W\x80`\x1F\x10a\r\xBDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\r\xE6V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r\xC9W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\rRV[`\x08T_\x90`\xFF\x16\x15a\x0E\x11WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\xC3\x91\x90a\x16GV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\xD0W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x0F\xF7\x91\x90\x81\x01\x90a\x16\x8BV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x10\x15\x92\x91\x90a\x17?V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x101W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10U\x91\x90a\x16GV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10\xCEW__\xFD[PZ\xF1\x15\x80\x15a\x10\xE0W=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11`W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\x84\x91\x90a\x16\x06V[PPPPPV[`@Q\x7F\x88\xB4L\x85\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x88\xB4L\x85\x90a\x11\xDF\x90\x86\x90\x86\x90\x86\x90`\x04\x01a\x17`V[_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x11\xF5W__\xFD[PZ\xFA\x15\x80\x15a\x12\x07W=__>=_\xFD[PPPPPPPV[a\x0C\xD4\x80a\x17\x88\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x12jW\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\x126V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x8BW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x13qW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x13[\x84\x86Qa\x12uV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x13!V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x12\xC9V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x13\xE9W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x13\xA9V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x8BW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x14?`@\x88\x01\x82a\x12uV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x14Z\x81\x83a\x13\x97V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\x19V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x8BW`?\x19\x87\x86\x03\x01\x84Ra\x14\xB3\x85\x83Qa\x12uV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\x97V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x8BW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x156`@\x87\x01\x82a\x13\x97V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\xEEV[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\x15mW__\xFD[PV[____`\x80\x85\x87\x03\x12\x15a\x15\x83W__\xFD[\x845\x93P` \x85\x015a\x15\x95\x81a\x15LV[\x92P`@\x85\x015a\x15\xA5\x81a\x15LV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x15\xC9W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x16\0W\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x16\x16W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x16%W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x16=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02UW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02y\x91\x90a\x0B,V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xE6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\n\x91\x90a\x0BGV[\x83Q\x90\x91P\x81\x10\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\x9Es\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x85\x83a\x05\xB4V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xB3\x90\x85\x90\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\x90`\x84\x01[`@\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\x0FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05-W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05Q\x91\x90a\x0BGV[a\x05[\x91\x90a\x0B^V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xB3\x90\x85\x90\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\x90`d\x01a\x04OV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x06\n\x90\x84\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\x90`d\x01a\x04OV[PPPV[_a\x06p\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\x07\x1A\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\nW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x8E\x91\x90a\x0B\x9CV[a\x06\nW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[``a\x07(\x84\x84_\x85a\x072V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xC4W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08BW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[__\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\x08j\x91\x90a\x0B\xBBV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xA4W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xA9V[``\x91P[P\x91P\x91Pa\x08\xB9\x82\x82\x86a\x08\xC4V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xD3WP\x81a\x07+V[\x82Q\x15a\x08\xE3W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03t\x91\x90a\x0B\xD1V[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\t8W__\xFD[PV[\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\x8BWa\t\x8Ba\t;V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xBAWa\t\xBAa\t;V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xD5W__\xFD[\x845a\t\xE0\x81a\t\x17V[\x93P` \x85\x015\x92P`@\x85\x015a\t\xF7\x81a\t\x17V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x12W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\"W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nz9,\xA4\xD4K\x0C\x1B\x8D = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `setUp()` and selector `0x0a9254e4`. -```solidity -function setUp() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setUpCall; - ///Container type for the return parameters of the [`setUp()`](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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl setUpReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for setUpCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = setUpReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "setUp()"; - const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - setUpReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. -```solidity -function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferCall { - #[allow(missing_docs)] - pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub sender: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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::Uint<256>, - ); - #[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::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferCall) -> Self { - (value.forkAtBlock, value.sender, value.receiver, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - forkAtBlock: tuple.0, - sender: tuple.1, - receiver: tuple.2, - amount: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl simulateForkAndTransferReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for simulateForkAndTransferCall { - type Parameters<'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::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = simulateForkAndTransferReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; - const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), - ::tokenize( - &self.sender, - ), - ::tokenize( - &self.receiver, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - simulateForkAndTransferReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testBedrockStrategy()` and selector `0x3d8127e0`. -```solidity -function testBedrockStrategy() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testBedrockStrategyCall; - ///Container type for the return parameters of the [`testBedrockStrategy()`](testBedrockStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testBedrockStrategyReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testBedrockStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testBedrockStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testBedrockStrategyReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testBedrockStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testBedrockStrategyReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testBedrockStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testBedrockStrategyReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testBedrockStrategy()"; - const SELECTOR: [u8; 4] = [61u8, 129u8, 39u8, 224u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testBedrockStrategyReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `token()` and selector `0xfc0c546a`. -```solidity -function token() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`token()`](tokenCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for tokenCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "token()"; - const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`BedrockStrategyForked`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum BedrockStrategyForkedCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - setUp(setUpCall), - #[allow(missing_docs)] - simulateForkAndTransfer(simulateForkAndTransferCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - testBedrockStrategy(testBedrockStrategyCall), - #[allow(missing_docs)] - token(tokenCall), - } - #[automatically_derived] - impl BedrockStrategyForkedCalls { - /// 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]] = &[ - [10u8, 146u8, 84u8, 228u8], - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [61u8, 129u8, 39u8, 224u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [102u8, 217u8, 169u8, 160u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [226u8, 12u8, 159u8, 113u8], - [249u8, 206u8, 14u8, 90u8], - [250u8, 118u8, 38u8, 212u8], - [252u8, 12u8, 84u8, 106u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for BedrockStrategyForkedCalls { - const NAME: &'static str = "BedrockStrategyForkedCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 16usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::setUp(_) => ::SELECTOR, - Self::simulateForkAndTransfer(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::testBedrockStrategy(_) => { - ::SELECTOR - } - Self::token(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(BedrockStrategyForkedCalls::setUp) - } - setUp - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BedrockStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BedrockStrategyForkedCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn testBedrockStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BedrockStrategyForkedCalls::testBedrockStrategy) - } - testBedrockStrategy - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BedrockStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BedrockStrategyForkedCalls::targetContracts) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BedrockStrategyForkedCalls::targetArtifactSelectors) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BedrockStrategyForkedCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BedrockStrategyForkedCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BedrockStrategyForkedCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BedrockStrategyForkedCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(BedrockStrategyForkedCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BedrockStrategyForkedCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BedrockStrategyForkedCalls::simulateForkAndTransfer) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(BedrockStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(BedrockStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BedrockStrategyForkedCalls::setUp) - } - setUp - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BedrockStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BedrockStrategyForkedCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn testBedrockStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BedrockStrategyForkedCalls::testBedrockStrategy) - } - testBedrockStrategy - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BedrockStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BedrockStrategyForkedCalls::targetContracts) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BedrockStrategyForkedCalls::targetArtifactSelectors) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BedrockStrategyForkedCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BedrockStrategyForkedCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BedrockStrategyForkedCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BedrockStrategyForkedCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BedrockStrategyForkedCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BedrockStrategyForkedCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BedrockStrategyForkedCalls::simulateForkAndTransfer) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BedrockStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BedrockStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::setUp(inner) => { - ::abi_encoded_size(inner) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testBedrockStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::token(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::setUp(inner) => { - ::abi_encode_raw(inner, out) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testBedrockStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::token(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - ///Container for all the [`BedrockStrategyForked`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum BedrockStrategyForkedEvents { - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl BedrockStrategyForkedEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for BedrockStrategyForkedEvents { - const NAME: &'static str = "BedrockStrategyForkedEvents"; - const COUNT: usize = 22usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 BedrockStrategyForkedEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`BedrockStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`BedrockStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> BedrockStrategyForkedInstance { - BedrockStrategyForkedInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - BedrockStrategyForkedInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - BedrockStrategyForkedInstance::::deploy_builder(provider) - } - /**A [`BedrockStrategyForked`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`BedrockStrategyForked`](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 BedrockStrategyForkedInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for BedrockStrategyForkedInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("BedrockStrategyForkedInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BedrockStrategyForkedInstance { - /**Creates a new wrapper around an on-chain [`BedrockStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`BedrockStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 BedrockStrategyForkedInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> BedrockStrategyForkedInstance { - BedrockStrategyForkedInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BedrockStrategyForkedInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`setUp`] function. - pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { - self.call_builder(&setUpCall) - } - ///Creates a new call builder for the [`simulateForkAndTransfer`] function. - pub fn simulateForkAndTransfer( - &self, - forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - sender: alloy::sol_types::private::Address, - receiver: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { - self.call_builder( - &simulateForkAndTransferCall { - forkAtBlock, - sender, - receiver, - amount, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`testBedrockStrategy`] function. - pub fn testBedrockStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testBedrockStrategyCall, N> { - self.call_builder(&testBedrockStrategyCall) - } - ///Creates a new call builder for the [`token`] function. - pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { - self.call_builder(&tokenCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BedrockStrategyForkedInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/bitcoin_tx.rs b/crates/bindings/src/bitcoin_tx.rs deleted file mode 100644 index fac25a1ca..000000000 --- a/crates/bindings/src/bitcoin_tx.rs +++ /dev/null @@ -1,218 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface BitcoinTx {} -``` - -...which was generated by the following JSON ABI: -```json -[] -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod BitcoinTx { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220a68ee4a95430b1a47f2aaf420ef14a7f295c85c26a631128e0b894b630ddc31364736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"`U`2`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`&WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \xA6\x8E\xE4\xA9T0\xB1\xA4\x7F*\xAFB\x0E\xF1J\x7F)\\\x85\xC2jc\x11(\xE0\xB8\x94\xB60\xDD\xC3\x13dsolcC\0\x08\x1C\x003", - ); - /// The runtime bytecode of the contract, as deployed on the network. - /// - /// ```text - ///0x730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220a68ee4a95430b1a47f2aaf420ef14a7f295c85c26a631128e0b894b630ddc31364736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \xA6\x8E\xE4\xA9T0\xB1\xA4\x7F*\xAFB\x0E\xF1J\x7F)\\\x85\xC2jc\x11(\xE0\xB8\x94\xB60\xDD\xC3\x13dsolcC\0\x08\x1C\x003", - ); - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`BitcoinTx`](self) contract instance. - -See the [wrapper's documentation](`BitcoinTxInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> BitcoinTxInstance { - BitcoinTxInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - BitcoinTxInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - BitcoinTxInstance::::deploy_builder(provider) - } - /**A [`BitcoinTx`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`BitcoinTx`](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 BitcoinTxInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for BitcoinTxInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("BitcoinTxInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BitcoinTxInstance { - /**Creates a new wrapper around an on-chain [`BitcoinTx`](self) contract instance. - -See the [wrapper's documentation](`BitcoinTxInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 BitcoinTxInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> BitcoinTxInstance { - BitcoinTxInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BitcoinTxInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BitcoinTxInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/bitcoin_tx_builder.rs b/crates/bindings/src/bitcoin_tx_builder.rs deleted file mode 100644 index 790f71bb8..000000000 --- a/crates/bindings/src/bitcoin_tx_builder.rs +++ /dev/null @@ -1,1571 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library BitcoinTx { - struct Info { bytes4 version; bytes inputVector; bytes outputVector; bytes4 locktime; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod BitcoinTx { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct Info { bytes4 version; bytes inputVector; bytes outputVector; bytes4 locktime; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct Info { - #[allow(missing_docs)] - pub version: alloy::sol_types::private::FixedBytes<4>, - #[allow(missing_docs)] - pub inputVector: alloy::sol_types::private::Bytes, - #[allow(missing_docs)] - pub outputVector: alloy::sol_types::private::Bytes, - #[allow(missing_docs)] - pub locktime: 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::FixedBytes<4>, - alloy::sol_types::sol_data::Bytes, - alloy::sol_types::sol_data::Bytes, - alloy::sol_types::sol_data::FixedBytes<4>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::FixedBytes<4>, - alloy::sol_types::private::Bytes, - alloy::sol_types::private::Bytes, - alloy::sol_types::private::FixedBytes<4>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: Info) -> Self { - (value.version, value.inputVector, value.outputVector, value.locktime) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for Info { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - version: tuple.0, - inputVector: tuple.1, - outputVector: tuple.2, - locktime: tuple.3, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for Info { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for Info { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.version), - ::tokenize( - &self.inputVector, - ), - ::tokenize( - &self.outputVector, - ), - as alloy_sol_types::SolType>::tokenize(&self.locktime), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for Info { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for Info { - const NAME: &'static str = "Info"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "Info(bytes4 version,bytes inputVector,bytes outputVector,bytes4 locktime)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - as alloy_sol_types::SolType>::eip712_data_word(&self.version) - .0, - ::eip712_data_word( - &self.inputVector, - ) - .0, - ::eip712_data_word( - &self.outputVector, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.locktime) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for Info { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.version, - ) - + ::topic_preimage_length( - &rust.inputVector, - ) - + ::topic_preimage_length( - &rust.outputVector, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.locktime, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.version, - out, - ); - ::encode_topic_preimage( - &rust.inputVector, - out, - ); - ::encode_topic_preimage( - &rust.outputVector, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.locktime, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`BitcoinTx`](self) contract instance. - -See the [wrapper's documentation](`BitcoinTxInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> BitcoinTxInstance { - BitcoinTxInstance::::new(address, provider) - } - /**A [`BitcoinTx`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`BitcoinTx`](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 BitcoinTxInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for BitcoinTxInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("BitcoinTxInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BitcoinTxInstance { - /**Creates a new wrapper around an on-chain [`BitcoinTx`](self) contract instance. - -See the [wrapper's documentation](`BitcoinTxInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 BitcoinTxInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> BitcoinTxInstance { - BitcoinTxInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BitcoinTxInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BitcoinTxInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library BitcoinTx { - struct Info { - bytes4 version; - bytes inputVector; - bytes outputVector; - bytes4 locktime; - } -} - -interface BitcoinTxBuilder { - function build() external view returns (BitcoinTx.Info memory); - function setOpReturn(bytes memory _data) external returns (address); - function setScript(bytes memory _script) external returns (address); - function setValue(uint64 _value) external returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "build", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "tuple", - "internalType": "struct BitcoinTx.Info", - "components": [ - { - "name": "version", - "type": "bytes4", - "internalType": "bytes4" - }, - { - "name": "inputVector", - "type": "bytes", - "internalType": "bytes" - }, - { - "name": "outputVector", - "type": "bytes", - "internalType": "bytes" - }, - { - "name": "locktime", - "type": "bytes4", - "internalType": "bytes4" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "setOpReturn", - "inputs": [ - { - "name": "_data", - "type": "bytes", - "internalType": "bytes" - } - ], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract BitcoinTxBuilder" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "setScript", - "inputs": [ - { - "name": "_script", - "type": "bytes", - "internalType": "bytes" - } - ], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract BitcoinTxBuilder" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "setValue", - "inputs": [ - { - "name": "_value", - "type": "uint64", - "internalType": "uint64" - } - ], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract BitcoinTxBuilder" - } - ], - "stateMutability": "nonpayable" - } -] -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod BitcoinTxBuilder { - use super::*; - use alloy::sol_types as 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\ts\x80a\0\x1C_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\r\x15\xA3J\x14a\0NW\x80c\x1CN\xD3'\x14a\0\x8BW\x80c\x8E\x1AU\xFC\x14a\0\xD6W\x80c\xFC\xAB^H\x14a\0\xEBW[__\xFD[a\0aa\0\\6`\x04a\x04LV[a\0\xFEV[`@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\0aa\0\x996`\x04a\x05\0V[`\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\0\0\0\0\0\0\0\0\x16g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x90\x92\x16\x91\x90\x91\x17\x90U0\x90V[a\0\xDEa\x01\x12V[`@Qa\0\x82\x91\x90a\x05\\V[a\0aa\0\xF96`\x04a\x04LV[a\x03\xDFV[_\x80a\x01\n\x83\x82a\x06\x96V[P0\x92\x91PPV[`@\x80Q`\x80\x81\x01\x82R_\x80\x82R``` \x83\x01\x81\x90R\x92\x82\x01\x83\x90R\x91\x81\x01\x91\x90\x91R_\x80T\x81\x90a\x01D\x90a\x05\xF9V[\x90P\x11a\x01\xB2W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x7FScript cannot be empty\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`\x01Th\x01\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x02DW`P_`\x02\x01\x80Ta\x01\xDA\x90a\x05\xF9V[\x90P\x11\x15a\x02DW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x7FOP_RETURN data too large\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x01\xA9V[`\x01T_\x90e\xFF\xFF\0\0\xFF\xFFg\xFF\0\xFF\0\xFF\0\xFF\0`\x08\x83\x81\x1B\x91\x82\x16f\xFF\0\xFF\0\xFF\0\xFF\x94\x90\x91\x1C\x93\x84\x16\x17`\x10\x90\x81\x1C\x92\x90\x92\x16e\xFF\0\0\0\xFF\0\x91\x90\x91\x16d\xFF\0\0\0\xFF\x93\x90\x93\x16\x92\x90\x92\x17\x90\x1Bg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17` \x81\x81\x1B\x91\x90\x1C\x17`\xC0\x1B`@Q` \x01a\x02\xE4\x91\x90\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\x91\x90\x91\x16\x81R`\x08\x01\x90V[`@\x80Q\x80\x83\x03`\x1F\x19\x01\x81R\x91\x90R`\x01\x80T\x91\x92P\x90h\x01\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x03\x1EWa\x03\x1B`\x01\x82a\x07~V[\x90P[`@Q_\x90a\x035\x90\x83\x90\x85\x90\x84\x90` \x01a\x08@V[`@\x80Q\x80\x83\x03`\x1F\x19\x01\x81R\x91\x90R`\x01T\x90\x91Ph\x01\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x03\xAFW\x80_`\x02\x01\x80Ta\x03o\x90a\x05\xF9V[a\x03{\x91P`\x02a\x08\x88V[`\x02\x80Ta\x03\x88\x90a\x05\xF9V[`@Qa\x03\x9D\x94\x93\x92P`\x02\x90` \x01a\x08\x9BV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90P[`@\x80Q`\x80\x81\x01\x82R_\x80\x82R\x82Q` \x81\x81\x01\x85R\x82\x82R\x83\x01R\x91\x81\x01\x92\x90\x92R``\x82\x01R\x93\x92PPPV[`\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\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16h\x01\0\0\0\0\0\0\0\0\x17\x90U_`\x02a\x01\n\x83\x82a\x06\x96V[\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\x04\\W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x04rW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x04\x82W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x04\x9CWa\x04\x9Ca\x04\x1FV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x04\xCCWa\x04\xCCa\x04\x1FV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x04\xE3W__\xFD[\x81` \x84\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[_` \x82\x84\x03\x12\x15a\x05\x10W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x05'W__\xFD[\x93\x92PPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R\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\x82Q\x16` \x82\x01R_` \x83\x01Q`\x80`@\x84\x01Ra\x05\xA3`\xA0\x84\x01\x82a\x05.V[\x90P`@\x84\x01Q`\x1F\x19\x84\x83\x03\x01``\x85\x01Ra\x05\xC0\x82\x82a\x05.V[\x91PP\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``\x85\x01Q\x16`\x80\x84\x01R\x80\x91PP\x92\x91PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x06\rW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x06DW\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[P\x91\x90PV[`\x1F\x82\x11\x15a\x06\x91W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x06oWP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x06\x8EW_\x81U`\x01\x01a\x06{V[PP[PPPV[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\xB0Wa\x06\xB0a\x04\x1FV[a\x06\xC4\x81a\x06\xBE\x84Ta\x05\xF9V[\x84a\x06JV[` `\x1F\x82\x11`\x01\x81\x14a\x06\xF6W_\x83\x15a\x06\xDFWP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x06\x8EV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x07%W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x07\x05V[P\x84\x82\x10\x15a\x07BW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[\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[`\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x07\x97Wa\x07\x97a\x07QV[\x92\x91PPV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_\x81Ta\x07\xC0\x81a\x05\xF9V[`\x01\x82\x16\x80\x15a\x07\xD7W`\x01\x81\x14a\x08\nWa\x087V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x83\x16\x86R\x81\x15\x15\x82\x02\x86\x01\x93Pa\x087V[\x84_R` _ _[\x83\x81\x10\x15a\x08/W\x81T\x88\x82\x01R`\x01\x90\x91\x01\x90` \x01a\x08\x13V[PP\x81\x86\x01\x93P[PPP\x92\x91PPV[\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\x84`\xF8\x1B\x16\x81R_a\x08\x7Fa\x08y`\x01\x84\x01\x86a\x07\x9DV[\x84a\x07\xB4V[\x95\x94PPPPPV[\x80\x82\x01\x80\x82\x11\x15a\x07\x97Wa\x07\x97a\x07QV[_a\x08\xA6\x82\x87a\x07\x9DV[_\x81R\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\x86`\xF8\x1B\x16`\x08\x82\x01R\x7Fj\0\0\0\0\0\0\0\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\x82\x01R\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\x85`\xF8\x1B\x16`\n\x82\x01Ra\t2`\x0B\x82\x01\x85a\x07\xB4V[\x97\x96PPPPPPPV\xFE\xA2dipfsX\"\x12 p\xD9\xC0\xD4\n7\xF7E_\x06\x13\xEB\x14\xD5\xEF\xEEa>\xA6\xFE,\xD3P\xE4\xA4\xB0Sd]\x92\xA6XdsolcC\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\r\x15\xA3J\x14a\0NW\x80c\x1CN\xD3'\x14a\0\x8BW\x80c\x8E\x1AU\xFC\x14a\0\xD6W\x80c\xFC\xAB^H\x14a\0\xEBW[__\xFD[a\0aa\0\\6`\x04a\x04LV[a\0\xFEV[`@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\0aa\0\x996`\x04a\x05\0V[`\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\0\0\0\0\0\0\0\0\x16g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x90\x92\x16\x91\x90\x91\x17\x90U0\x90V[a\0\xDEa\x01\x12V[`@Qa\0\x82\x91\x90a\x05\\V[a\0aa\0\xF96`\x04a\x04LV[a\x03\xDFV[_\x80a\x01\n\x83\x82a\x06\x96V[P0\x92\x91PPV[`@\x80Q`\x80\x81\x01\x82R_\x80\x82R``` \x83\x01\x81\x90R\x92\x82\x01\x83\x90R\x91\x81\x01\x91\x90\x91R_\x80T\x81\x90a\x01D\x90a\x05\xF9V[\x90P\x11a\x01\xB2W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x7FScript cannot be empty\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`\x01Th\x01\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x02DW`P_`\x02\x01\x80Ta\x01\xDA\x90a\x05\xF9V[\x90P\x11\x15a\x02DW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x7FOP_RETURN data too large\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x01\xA9V[`\x01T_\x90e\xFF\xFF\0\0\xFF\xFFg\xFF\0\xFF\0\xFF\0\xFF\0`\x08\x83\x81\x1B\x91\x82\x16f\xFF\0\xFF\0\xFF\0\xFF\x94\x90\x91\x1C\x93\x84\x16\x17`\x10\x90\x81\x1C\x92\x90\x92\x16e\xFF\0\0\0\xFF\0\x91\x90\x91\x16d\xFF\0\0\0\xFF\x93\x90\x93\x16\x92\x90\x92\x17\x90\x1Bg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17` \x81\x81\x1B\x91\x90\x1C\x17`\xC0\x1B`@Q` \x01a\x02\xE4\x91\x90\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\x91\x90\x91\x16\x81R`\x08\x01\x90V[`@\x80Q\x80\x83\x03`\x1F\x19\x01\x81R\x91\x90R`\x01\x80T\x91\x92P\x90h\x01\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x03\x1EWa\x03\x1B`\x01\x82a\x07~V[\x90P[`@Q_\x90a\x035\x90\x83\x90\x85\x90\x84\x90` \x01a\x08@V[`@\x80Q\x80\x83\x03`\x1F\x19\x01\x81R\x91\x90R`\x01T\x90\x91Ph\x01\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x03\xAFW\x80_`\x02\x01\x80Ta\x03o\x90a\x05\xF9V[a\x03{\x91P`\x02a\x08\x88V[`\x02\x80Ta\x03\x88\x90a\x05\xF9V[`@Qa\x03\x9D\x94\x93\x92P`\x02\x90` \x01a\x08\x9BV[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x90P[`@\x80Q`\x80\x81\x01\x82R_\x80\x82R\x82Q` \x81\x81\x01\x85R\x82\x82R\x83\x01R\x91\x81\x01\x92\x90\x92R``\x82\x01R\x93\x92PPPV[`\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\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16h\x01\0\0\0\0\0\0\0\0\x17\x90U_`\x02a\x01\n\x83\x82a\x06\x96V[\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\x04\\W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x04rW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x04\x82W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x04\x9CWa\x04\x9Ca\x04\x1FV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x04\xCCWa\x04\xCCa\x04\x1FV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x04\xE3W__\xFD[\x81` \x84\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[_` \x82\x84\x03\x12\x15a\x05\x10W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x05'W__\xFD[\x93\x92PPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[` \x81R\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\x82Q\x16` \x82\x01R_` \x83\x01Q`\x80`@\x84\x01Ra\x05\xA3`\xA0\x84\x01\x82a\x05.V[\x90P`@\x84\x01Q`\x1F\x19\x84\x83\x03\x01``\x85\x01Ra\x05\xC0\x82\x82a\x05.V[\x91PP\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``\x85\x01Q\x16`\x80\x84\x01R\x80\x91PP\x92\x91PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x06\rW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x06DW\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[P\x91\x90PV[`\x1F\x82\x11\x15a\x06\x91W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x06oWP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x06\x8EW_\x81U`\x01\x01a\x06{V[PP[PPPV[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\xB0Wa\x06\xB0a\x04\x1FV[a\x06\xC4\x81a\x06\xBE\x84Ta\x05\xF9V[\x84a\x06JV[` `\x1F\x82\x11`\x01\x81\x14a\x06\xF6W_\x83\x15a\x06\xDFWP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x06\x8EV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x07%W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x07\x05V[P\x84\x82\x10\x15a\x07BW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[\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[`\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x07\x97Wa\x07\x97a\x07QV[\x92\x91PPV[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[_\x81Ta\x07\xC0\x81a\x05\xF9V[`\x01\x82\x16\x80\x15a\x07\xD7W`\x01\x81\x14a\x08\nWa\x087V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x83\x16\x86R\x81\x15\x15\x82\x02\x86\x01\x93Pa\x087V[\x84_R` _ _[\x83\x81\x10\x15a\x08/W\x81T\x88\x82\x01R`\x01\x90\x91\x01\x90` \x01a\x08\x13V[PP\x81\x86\x01\x93P[PPP\x92\x91PPV[\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\x84`\xF8\x1B\x16\x81R_a\x08\x7Fa\x08y`\x01\x84\x01\x86a\x07\x9DV[\x84a\x07\xB4V[\x95\x94PPPPPV[\x80\x82\x01\x80\x82\x11\x15a\x07\x97Wa\x07\x97a\x07QV[_a\x08\xA6\x82\x87a\x07\x9DV[_\x81R\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\x86`\xF8\x1B\x16`\x08\x82\x01R\x7Fj\0\0\0\0\0\0\0\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\x82\x01R\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\x85`\xF8\x1B\x16`\n\x82\x01Ra\t2`\x0B\x82\x01\x85a\x07\xB4V[\x97\x96PPPPPPPV\xFE\xA2dipfsX\"\x12 p\xD9\xC0\xD4\n7\xF7E_\x06\x13\xEB\x14\xD5\xEF\xEEa>\xA6\xFE,\xD3P\xE4\xA4\xB0Sd]\x92\xA6XdsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `build()` and selector `0x8e1a55fc`. -```solidity -function build() external view returns (BitcoinTx.Info memory); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct buildCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`build()`](buildCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct buildReturn { - #[allow(missing_docs)] - pub _0: ::RustType, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: buildCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for buildCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (BitcoinTx::Info,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - ::RustType, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: buildReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for buildReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for buildCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = ::RustType; - type ReturnTuple<'a> = (BitcoinTx::Info,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "build()"; - const SELECTOR: [u8; 4] = [142u8, 26u8, 85u8, 252u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - (::tokenize(ret),) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: buildReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: buildReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `setOpReturn(bytes)` and selector `0xfcab5e48`. -```solidity -function setOpReturn(bytes memory _data) external returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setOpReturnCall { - #[allow(missing_docs)] - pub _data: alloy::sol_types::private::Bytes, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`setOpReturn(bytes)`](setOpReturnCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setOpReturnReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setOpReturnCall) -> Self { - (value._data,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setOpReturnCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _data: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setOpReturnReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setOpReturnReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for setOpReturnCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Bytes,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "setOpReturn(bytes)"; - const SELECTOR: [u8; 4] = [252u8, 171u8, 94u8, 72u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._data, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: setOpReturnReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: setOpReturnReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `setScript(bytes)` and selector `0x0d15a34a`. -```solidity -function setScript(bytes memory _script) external returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setScriptCall { - #[allow(missing_docs)] - pub _script: alloy::sol_types::private::Bytes, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`setScript(bytes)`](setScriptCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setScriptReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setScriptCall) -> Self { - (value._script,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setScriptCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _script: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setScriptReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setScriptReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for setScriptCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Bytes,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "setScript(bytes)"; - const SELECTOR: [u8; 4] = [13u8, 21u8, 163u8, 74u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._script, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: setScriptReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: setScriptReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `setValue(uint64)` and selector `0x1c4ed327`. -```solidity -function setValue(uint64 _value) external returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setValueCall { - #[allow(missing_docs)] - pub _value: u64, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`setValue(uint64)`](setValueCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setValueReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (u64,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setValueCall) -> Self { - (value._value,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setValueCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _value: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setValueReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setValueReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for setValueCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<64>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "setValue(uint64)"; - const SELECTOR: [u8; 4] = [28u8, 78u8, 211u8, 39u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._value), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: setValueReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: setValueReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`BitcoinTxBuilder`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum BitcoinTxBuilderCalls { - #[allow(missing_docs)] - build(buildCall), - #[allow(missing_docs)] - setOpReturn(setOpReturnCall), - #[allow(missing_docs)] - setScript(setScriptCall), - #[allow(missing_docs)] - setValue(setValueCall), - } - #[automatically_derived] - impl BitcoinTxBuilderCalls { - /// 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, 21u8, 163u8, 74u8], - [28u8, 78u8, 211u8, 39u8], - [142u8, 26u8, 85u8, 252u8], - [252u8, 171u8, 94u8, 72u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for BitcoinTxBuilderCalls { - const NAME: &'static str = "BitcoinTxBuilderCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 4usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::build(_) => ::SELECTOR, - Self::setOpReturn(_) => { - ::SELECTOR - } - Self::setScript(_) => { - ::SELECTOR - } - Self::setValue(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setScript( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(BitcoinTxBuilderCalls::setScript) - } - setScript - }, - { - fn setValue( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(BitcoinTxBuilderCalls::setValue) - } - setValue - }, - { - fn build( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(BitcoinTxBuilderCalls::build) - } - build - }, - { - fn setOpReturn( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BitcoinTxBuilderCalls::setOpReturn) - } - setOpReturn - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setScript( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BitcoinTxBuilderCalls::setScript) - } - setScript - }, - { - fn setValue( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BitcoinTxBuilderCalls::setValue) - } - setValue - }, - { - fn build( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BitcoinTxBuilderCalls::build) - } - build - }, - { - fn setOpReturn( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BitcoinTxBuilderCalls::setOpReturn) - } - setOpReturn - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::build(inner) => { - ::abi_encoded_size(inner) - } - Self::setOpReturn(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::setScript(inner) => { - ::abi_encoded_size(inner) - } - Self::setValue(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::build(inner) => { - ::abi_encode_raw(inner, out) - } - Self::setOpReturn(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::setScript(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::setValue(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`BitcoinTxBuilder`](self) contract instance. - -See the [wrapper's documentation](`BitcoinTxBuilderInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> BitcoinTxBuilderInstance { - BitcoinTxBuilderInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - BitcoinTxBuilderInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - BitcoinTxBuilderInstance::::deploy_builder(provider) - } - /**A [`BitcoinTxBuilder`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`BitcoinTxBuilder`](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 BitcoinTxBuilderInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for BitcoinTxBuilderInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("BitcoinTxBuilderInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BitcoinTxBuilderInstance { - /**Creates a new wrapper around an on-chain [`BitcoinTxBuilder`](self) contract instance. - -See the [wrapper's documentation](`BitcoinTxBuilderInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 BitcoinTxBuilderInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> BitcoinTxBuilderInstance { - BitcoinTxBuilderInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BitcoinTxBuilderInstance { - /// 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( - &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 [`build`] function. - pub fn build(&self) -> alloy_contract::SolCallBuilder<&P, buildCall, N> { - self.call_builder(&buildCall) - } - ///Creates a new call builder for the [`setOpReturn`] function. - pub fn setOpReturn( - &self, - _data: alloy::sol_types::private::Bytes, - ) -> alloy_contract::SolCallBuilder<&P, setOpReturnCall, N> { - self.call_builder(&setOpReturnCall { _data }) - } - ///Creates a new call builder for the [`setScript`] function. - pub fn setScript( - &self, - _script: alloy::sol_types::private::Bytes, - ) -> alloy_contract::SolCallBuilder<&P, setScriptCall, N> { - self.call_builder(&setScriptCall { _script }) - } - ///Creates a new call builder for the [`setValue`] function. - pub fn setValue( - &self, - _value: u64, - ) -> alloy_contract::SolCallBuilder<&P, setValueCall, N> { - self.call_builder(&setValueCall { _value }) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BitcoinTxBuilderInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/btc_market_place.rs b/crates/bindings/src/btc_market_place.rs deleted file mode 100644 index c556a2877..000000000 --- a/crates/bindings/src/btc_market_place.rs +++ /dev/null @@ -1,9865 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library BitcoinTx { - struct Info { bytes4 version; bytes inputVector; bytes outputVector; bytes4 locktime; } - struct Proof { bytes merkleProof; uint256 txIndexInBlock; bytes bitcoinHeaders; bytes32 coinbasePreimage; bytes coinbaseProof; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod BitcoinTx { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct Info { bytes4 version; bytes inputVector; bytes outputVector; bytes4 locktime; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct Info { - #[allow(missing_docs)] - pub version: alloy::sol_types::private::FixedBytes<4>, - #[allow(missing_docs)] - pub inputVector: alloy::sol_types::private::Bytes, - #[allow(missing_docs)] - pub outputVector: alloy::sol_types::private::Bytes, - #[allow(missing_docs)] - pub locktime: 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::FixedBytes<4>, - alloy::sol_types::sol_data::Bytes, - alloy::sol_types::sol_data::Bytes, - alloy::sol_types::sol_data::FixedBytes<4>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::FixedBytes<4>, - alloy::sol_types::private::Bytes, - alloy::sol_types::private::Bytes, - alloy::sol_types::private::FixedBytes<4>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: Info) -> Self { - (value.version, value.inputVector, value.outputVector, value.locktime) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for Info { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - version: tuple.0, - inputVector: tuple.1, - outputVector: tuple.2, - locktime: tuple.3, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for Info { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for Info { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.version), - ::tokenize( - &self.inputVector, - ), - ::tokenize( - &self.outputVector, - ), - as alloy_sol_types::SolType>::tokenize(&self.locktime), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for Info { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for Info { - const NAME: &'static str = "Info"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "Info(bytes4 version,bytes inputVector,bytes outputVector,bytes4 locktime)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - as alloy_sol_types::SolType>::eip712_data_word(&self.version) - .0, - ::eip712_data_word( - &self.inputVector, - ) - .0, - ::eip712_data_word( - &self.outputVector, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.locktime) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for Info { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.version, - ) - + ::topic_preimage_length( - &rust.inputVector, - ) - + ::topic_preimage_length( - &rust.outputVector, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.locktime, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.version, - out, - ); - ::encode_topic_preimage( - &rust.inputVector, - out, - ); - ::encode_topic_preimage( - &rust.outputVector, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.locktime, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct Proof { bytes merkleProof; uint256 txIndexInBlock; bytes bitcoinHeaders; bytes32 coinbasePreimage; bytes coinbaseProof; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct Proof { - #[allow(missing_docs)] - pub merkleProof: alloy::sol_types::private::Bytes, - #[allow(missing_docs)] - pub txIndexInBlock: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub bitcoinHeaders: alloy::sol_types::private::Bytes, - #[allow(missing_docs)] - pub coinbasePreimage: alloy::sol_types::private::FixedBytes<32>, - #[allow(missing_docs)] - pub coinbaseProof: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Bytes, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Bytes, - alloy::sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Bytes, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Bytes, - alloy::sol_types::private::primitives::aliases::U256, - alloy::sol_types::private::Bytes, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: Proof) -> Self { - ( - value.merkleProof, - value.txIndexInBlock, - value.bitcoinHeaders, - value.coinbasePreimage, - value.coinbaseProof, - ) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for Proof { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - merkleProof: tuple.0, - txIndexInBlock: tuple.1, - bitcoinHeaders: tuple.2, - coinbasePreimage: tuple.3, - coinbaseProof: tuple.4, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for Proof { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for Proof { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.merkleProof, - ), - as alloy_sol_types::SolType>::tokenize(&self.txIndexInBlock), - ::tokenize( - &self.bitcoinHeaders, - ), - as alloy_sol_types::SolType>::tokenize(&self.coinbasePreimage), - ::tokenize( - &self.coinbaseProof, - ), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for Proof { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for Proof { - const NAME: &'static str = "Proof"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "Proof(bytes merkleProof,uint256 txIndexInBlock,bytes bitcoinHeaders,bytes32 coinbasePreimage,bytes coinbaseProof)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.merkleProof, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word( - &self.txIndexInBlock, - ) - .0, - ::eip712_data_word( - &self.bitcoinHeaders, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word( - &self.coinbasePreimage, - ) - .0, - ::eip712_data_word( - &self.coinbaseProof, - ) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for Proof { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.merkleProof, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.txIndexInBlock, - ) - + ::topic_preimage_length( - &rust.bitcoinHeaders, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.coinbasePreimage, - ) - + ::topic_preimage_length( - &rust.coinbaseProof, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.merkleProof, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.txIndexInBlock, - out, - ); - ::encode_topic_preimage( - &rust.bitcoinHeaders, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.coinbasePreimage, - out, - ); - ::encode_topic_preimage( - &rust.coinbaseProof, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`BitcoinTx`](self) contract instance. - -See the [wrapper's documentation](`BitcoinTxInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> BitcoinTxInstance { - BitcoinTxInstance::::new(address, provider) - } - /**A [`BitcoinTx`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`BitcoinTx`](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 BitcoinTxInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for BitcoinTxInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("BitcoinTxInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BitcoinTxInstance { - /**Creates a new wrapper around an on-chain [`BitcoinTx`](self) contract instance. - -See the [wrapper's documentation](`BitcoinTxInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 BitcoinTxInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> BitcoinTxInstance { - BitcoinTxInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BitcoinTxInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BitcoinTxInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library BitcoinTx { - struct Info { - bytes4 version; - bytes inputVector; - bytes outputVector; - bytes4 locktime; - } - struct Proof { - bytes merkleProof; - uint256 txIndexInBlock; - bytes bitcoinHeaders; - bytes32 coinbasePreimage; - bytes coinbaseProof; - } -} - -interface BtcMarketPlace { - struct AcceptedBtcBuyOrder { - uint256 orderId; - uint256 amountBtc; - address ercToken; - uint256 ercAmount; - address requester; - address accepter; - uint256 acceptTime; - } - struct AcceptedBtcSellOrder { - uint256 orderId; - BitcoinAddress bitcoinAddress; - uint256 amountBtc; - address ercToken; - uint256 ercAmount; - address requester; - address accepter; - uint256 acceptTime; - } - struct BitcoinAddress { - bytes scriptPubKey; - } - struct BtcBuyOrder { - uint256 amountBtc; - BitcoinAddress bitcoinAddress; - address offeringToken; - uint256 offeringAmount; - address requester; - } - struct BtcSellOrder { - uint256 amountBtc; - address askingToken; - uint256 askingAmount; - address requester; - } - - event acceptBtcBuyOrderEvent(uint256 indexed orderId, uint256 indexed acceptId, uint256 amountBtc, uint256 ercAmount, address ercToken); - event acceptBtcSellOrderEvent(uint256 indexed id, uint256 indexed acceptId, BitcoinAddress bitcoinAddress, uint256 amountBtc, uint256 ercAmount, address ercToken); - event cancelAcceptedBtcBuyOrderEvent(uint256 id); - event cancelAcceptedBtcSellOrderEvent(uint256 id); - event placeBtcBuyOrderEvent(uint256 amountBtc, BitcoinAddress bitcoinAddress, address sellingToken, uint256 saleAmount); - event placeBtcSellOrderEvent(uint256 indexed orderId, uint256 amountBtc, address buyingToken, uint256 buyAmount); - event proofBtcBuyOrderEvent(uint256 id); - event proofBtcSellOrderEvent(uint256 id); - event withdrawBtcBuyOrderEvent(uint256 id); - event withdrawBtcSellOrderEvent(uint256 id); - - constructor(address _relay, address erc2771Forwarder); - - function REQUEST_EXPIRATION_SECONDS() external view returns (uint256); - function acceptBtcBuyOrder(uint256 id, uint256 amountBtc) external returns (uint256); - function acceptBtcSellOrder(uint256 id, BitcoinAddress memory bitcoinAddress, uint256 amountBtc) external returns (uint256); - function acceptedBtcBuyOrders(uint256) external view returns (uint256 orderId, uint256 amountBtc, address ercToken, uint256 ercAmount, address requester, address accepter, uint256 acceptTime); - function acceptedBtcSellOrders(uint256) external view returns (uint256 orderId, BitcoinAddress memory bitcoinAddress, uint256 amountBtc, address ercToken, uint256 ercAmount, address requester, address accepter, uint256 acceptTime); - function btcBuyOrders(uint256) external view returns (uint256 amountBtc, BitcoinAddress memory bitcoinAddress, address offeringToken, uint256 offeringAmount, address requester); - function btcSellOrders(uint256) external view returns (uint256 amountBtc, address askingToken, uint256 askingAmount, address requester); - function cancelAcceptedBtcBuyOrder(uint256 id) external; - function cancelAcceptedBtcSellOrder(uint256 id) external; - function getOpenAcceptedBtcBuyOrders() external view returns (AcceptedBtcBuyOrder[] memory, uint256[] memory); - function getOpenAcceptedBtcSellOrders() external view returns (AcceptedBtcSellOrder[] memory, uint256[] memory); - function getOpenBtcBuyOrders() external view returns (BtcBuyOrder[] memory, uint256[] memory); - function getOpenBtcSellOrders() external view returns (BtcSellOrder[] memory, uint256[] memory); - function getTrustedForwarder() external view returns (address forwarder); - function isTrustedForwarder(address forwarder) external view returns (bool); - function placeBtcBuyOrder(uint256 amountBtc, BitcoinAddress memory bitcoinAddress, address sellingToken, uint256 saleAmount) external; - function placeBtcSellOrder(uint256 amountBtc, address buyingToken, uint256 buyAmount) external; - function proofBtcBuyOrder(uint256 id, BitcoinTx.Info memory transaction, BitcoinTx.Proof memory proof) external; - function proofBtcSellOrder(uint256 id, BitcoinTx.Info memory transaction, BitcoinTx.Proof memory proof) external; - function withdrawBtcBuyOrder(uint256 id) external; - function withdrawBtcSellOrder(uint256 id) external; -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "_relay", - "type": "address", - "internalType": "contract TestLightRelay" - }, - { - "name": "erc2771Forwarder", - "type": "address", - "internalType": "address" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "REQUEST_EXPIRATION_SECONDS", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "acceptBtcBuyOrder", - "inputs": [ - { - "name": "id", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "amountBtc", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "acceptBtcSellOrder", - "inputs": [ - { - "name": "id", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "bitcoinAddress", - "type": "tuple", - "internalType": "struct BtcMarketPlace.BitcoinAddress", - "components": [ - { - "name": "scriptPubKey", - "type": "bytes", - "internalType": "bytes" - } - ] - }, - { - "name": "amountBtc", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "acceptedBtcBuyOrders", - "inputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "orderId", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "amountBtc", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "ercToken", - "type": "address", - "internalType": "address" - }, - { - "name": "ercAmount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "requester", - "type": "address", - "internalType": "address" - }, - { - "name": "accepter", - "type": "address", - "internalType": "address" - }, - { - "name": "acceptTime", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "acceptedBtcSellOrders", - "inputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "orderId", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "bitcoinAddress", - "type": "tuple", - "internalType": "struct BtcMarketPlace.BitcoinAddress", - "components": [ - { - "name": "scriptPubKey", - "type": "bytes", - "internalType": "bytes" - } - ] - }, - { - "name": "amountBtc", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "ercToken", - "type": "address", - "internalType": "address" - }, - { - "name": "ercAmount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "requester", - "type": "address", - "internalType": "address" - }, - { - "name": "accepter", - "type": "address", - "internalType": "address" - }, - { - "name": "acceptTime", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "btcBuyOrders", - "inputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "amountBtc", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "bitcoinAddress", - "type": "tuple", - "internalType": "struct BtcMarketPlace.BitcoinAddress", - "components": [ - { - "name": "scriptPubKey", - "type": "bytes", - "internalType": "bytes" - } - ] - }, - { - "name": "offeringToken", - "type": "address", - "internalType": "address" - }, - { - "name": "offeringAmount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "requester", - "type": "address", - "internalType": "address" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "btcSellOrders", - "inputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "amountBtc", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "askingToken", - "type": "address", - "internalType": "address" - }, - { - "name": "askingAmount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "requester", - "type": "address", - "internalType": "address" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "cancelAcceptedBtcBuyOrder", - "inputs": [ - { - "name": "id", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "cancelAcceptedBtcSellOrder", - "inputs": [ - { - "name": "id", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "getOpenAcceptedBtcBuyOrders", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "tuple[]", - "internalType": "struct BtcMarketPlace.AcceptedBtcBuyOrder[]", - "components": [ - { - "name": "orderId", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "amountBtc", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "ercToken", - "type": "address", - "internalType": "address" - }, - { - "name": "ercAmount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "requester", - "type": "address", - "internalType": "address" - }, - { - "name": "accepter", - "type": "address", - "internalType": "address" - }, - { - "name": "acceptTime", - "type": "uint256", - "internalType": "uint256" - } - ] - }, - { - "name": "", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getOpenAcceptedBtcSellOrders", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "tuple[]", - "internalType": "struct BtcMarketPlace.AcceptedBtcSellOrder[]", - "components": [ - { - "name": "orderId", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "bitcoinAddress", - "type": "tuple", - "internalType": "struct BtcMarketPlace.BitcoinAddress", - "components": [ - { - "name": "scriptPubKey", - "type": "bytes", - "internalType": "bytes" - } - ] - }, - { - "name": "amountBtc", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "ercToken", - "type": "address", - "internalType": "address" - }, - { - "name": "ercAmount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "requester", - "type": "address", - "internalType": "address" - }, - { - "name": "accepter", - "type": "address", - "internalType": "address" - }, - { - "name": "acceptTime", - "type": "uint256", - "internalType": "uint256" - } - ] - }, - { - "name": "", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getOpenBtcBuyOrders", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "tuple[]", - "internalType": "struct BtcMarketPlace.BtcBuyOrder[]", - "components": [ - { - "name": "amountBtc", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "bitcoinAddress", - "type": "tuple", - "internalType": "struct BtcMarketPlace.BitcoinAddress", - "components": [ - { - "name": "scriptPubKey", - "type": "bytes", - "internalType": "bytes" - } - ] - }, - { - "name": "offeringToken", - "type": "address", - "internalType": "address" - }, - { - "name": "offeringAmount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "requester", - "type": "address", - "internalType": "address" - } - ] - }, - { - "name": "", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getOpenBtcSellOrders", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "tuple[]", - "internalType": "struct BtcMarketPlace.BtcSellOrder[]", - "components": [ - { - "name": "amountBtc", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "askingToken", - "type": "address", - "internalType": "address" - }, - { - "name": "askingAmount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "requester", - "type": "address", - "internalType": "address" - } - ] - }, - { - "name": "", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getTrustedForwarder", - "inputs": [], - "outputs": [ - { - "name": "forwarder", - "type": "address", - "internalType": "address" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "isTrustedForwarder", - "inputs": [ - { - "name": "forwarder", - "type": "address", - "internalType": "address" - } - ], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "placeBtcBuyOrder", - "inputs": [ - { - "name": "amountBtc", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "bitcoinAddress", - "type": "tuple", - "internalType": "struct BtcMarketPlace.BitcoinAddress", - "components": [ - { - "name": "scriptPubKey", - "type": "bytes", - "internalType": "bytes" - } - ] - }, - { - "name": "sellingToken", - "type": "address", - "internalType": "address" - }, - { - "name": "saleAmount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "placeBtcSellOrder", - "inputs": [ - { - "name": "amountBtc", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "buyingToken", - "type": "address", - "internalType": "address" - }, - { - "name": "buyAmount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "proofBtcBuyOrder", - "inputs": [ - { - "name": "id", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "transaction", - "type": "tuple", - "internalType": "struct BitcoinTx.Info", - "components": [ - { - "name": "version", - "type": "bytes4", - "internalType": "bytes4" - }, - { - "name": "inputVector", - "type": "bytes", - "internalType": "bytes" - }, - { - "name": "outputVector", - "type": "bytes", - "internalType": "bytes" - }, - { - "name": "locktime", - "type": "bytes4", - "internalType": "bytes4" - } - ] - }, - { - "name": "proof", - "type": "tuple", - "internalType": "struct BitcoinTx.Proof", - "components": [ - { - "name": "merkleProof", - "type": "bytes", - "internalType": "bytes" - }, - { - "name": "txIndexInBlock", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "bitcoinHeaders", - "type": "bytes", - "internalType": "bytes" - }, - { - "name": "coinbasePreimage", - "type": "bytes32", - "internalType": "bytes32" - }, - { - "name": "coinbaseProof", - "type": "bytes", - "internalType": "bytes" - } - ] - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "proofBtcSellOrder", - "inputs": [ - { - "name": "id", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "transaction", - "type": "tuple", - "internalType": "struct BitcoinTx.Info", - "components": [ - { - "name": "version", - "type": "bytes4", - "internalType": "bytes4" - }, - { - "name": "inputVector", - "type": "bytes", - "internalType": "bytes" - }, - { - "name": "outputVector", - "type": "bytes", - "internalType": "bytes" - }, - { - "name": "locktime", - "type": "bytes4", - "internalType": "bytes4" - } - ] - }, - { - "name": "proof", - "type": "tuple", - "internalType": "struct BitcoinTx.Proof", - "components": [ - { - "name": "merkleProof", - "type": "bytes", - "internalType": "bytes" - }, - { - "name": "txIndexInBlock", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "bitcoinHeaders", - "type": "bytes", - "internalType": "bytes" - }, - { - "name": "coinbasePreimage", - "type": "bytes32", - "internalType": "bytes32" - }, - { - "name": "coinbaseProof", - "type": "bytes", - "internalType": "bytes" - } - ] - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "withdrawBtcBuyOrder", - "inputs": [ - { - "name": "id", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "withdrawBtcSellOrder", - "inputs": [ - { - "name": "id", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "event", - "name": "acceptBtcBuyOrderEvent", - "inputs": [ - { - "name": "orderId", - "type": "uint256", - "indexed": true, - "internalType": "uint256" - }, - { - "name": "acceptId", - "type": "uint256", - "indexed": true, - "internalType": "uint256" - }, - { - "name": "amountBtc", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "ercAmount", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "ercToken", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "acceptBtcSellOrderEvent", - "inputs": [ - { - "name": "id", - "type": "uint256", - "indexed": true, - "internalType": "uint256" - }, - { - "name": "acceptId", - "type": "uint256", - "indexed": true, - "internalType": "uint256" - }, - { - "name": "bitcoinAddress", - "type": "tuple", - "indexed": false, - "internalType": "struct BtcMarketPlace.BitcoinAddress", - "components": [ - { - "name": "scriptPubKey", - "type": "bytes", - "internalType": "bytes" - } - ] - }, - { - "name": "amountBtc", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "ercAmount", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "ercToken", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "cancelAcceptedBtcBuyOrderEvent", - "inputs": [ - { - "name": "id", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "cancelAcceptedBtcSellOrderEvent", - "inputs": [ - { - "name": "id", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "placeBtcBuyOrderEvent", - "inputs": [ - { - "name": "amountBtc", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "bitcoinAddress", - "type": "tuple", - "indexed": false, - "internalType": "struct BtcMarketPlace.BitcoinAddress", - "components": [ - { - "name": "scriptPubKey", - "type": "bytes", - "internalType": "bytes" - } - ] - }, - { - "name": "sellingToken", - "type": "address", - "indexed": false, - "internalType": "address" - }, - { - "name": "saleAmount", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "placeBtcSellOrderEvent", - "inputs": [ - { - "name": "orderId", - "type": "uint256", - "indexed": true, - "internalType": "uint256" - }, - { - "name": "amountBtc", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "buyingToken", - "type": "address", - "indexed": false, - "internalType": "address" - }, - { - "name": "buyAmount", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "proofBtcBuyOrderEvent", - "inputs": [ - { - "name": "id", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "proofBtcSellOrderEvent", - "inputs": [ - { - "name": "id", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "withdrawBtcBuyOrderEvent", - "inputs": [ - { - "name": "id", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "withdrawBtcSellOrderEvent", - "inputs": [ - { - "name": "id", - "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 BtcMarketPlace { - use super::*; - use alloy::sol_types as 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[P`@QaE\xBA8\x03\x80aE\xBA\x839\x81\x01`@\x81\x90R`+\x91`\x81V[_\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x83\x16\x17\x90U`\x06\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x84\x16\x17\x90UPP`\x01`\x07U`\xB4V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14`~W__\xFD[PV[__`@\x83\x85\x03\x12\x15`\x91W__\xFD[\x82Q`\x9A\x81`kV[` \x84\x01Q\x90\x92P`\xA9\x81`kV[\x80\x91PP\x92P\x92\x90PV[aD\xF9\x80a\0\xC1_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01nW_5`\xE0\x1C\x80cj\x8C\xDE:\x11a\0\xD2W\x80c\xC5jE&\x11a\0\x88W\x80c\xDFi\xB1O\x11a\0cW\x80c\xDFi\xB1O\x14a\x03\xB2W\x80c\xEC\xCA,6\x14a\x03\xC5W\x80c\xFD?\xC2E\x14a\x042W__\xFD[\x80c\xC5jE&\x14a\x03|W\x80c\xCE\x1B\x81_\x14a\x03\x8FW\x80c\xD1\x92\x0F\xF0\x14a\x03\xA9W__\xFD[\x80c\xA3\x83\x01;\x11a\0\xB8W\x80c\xA3\x83\x01;\x14a\x02\xBAW\x80c\xB2#\xD9v\x14a\x02\xCDW\x80c\xBD*~>\x14a\x02\xE0W__\xFD[\x80cj\x8C\xDE:\x14a\x02\x8EW\x80c\x9C\xC6r.\x14a\x02\xA4W__\xFD[\x80cAEd\n\x11a\x01'W\x80cW+l\x05\x11a\x01\rW\x80cW+l\x05\x14a\x024W\x80c[\x8F\xE0B\x14a\x02eW\x80ch\x11\xA3\x11\x14a\x02xW__\xFD[\x80cAEd\n\x14a\x01\xFAW\x80cPj\x10\x9D\x14a\x02!W__\xFD[\x80c!\x0E\xC1\x81\x11a\x01WW\x80c!\x0E\xC1\x81\x14a\x01\xAEW\x80c6O\x1E\xC0\x14a\x01\xC1W\x80c:\xF3\xFC~\x14a\x01\xD6W__\xFD[\x80c\x11\xC17\xAA\x14a\x01rW\x80c\x1D\xFEu\x95\x14a\x01\x98W[__\xFD[a\x01\x85a\x01\x806`\x04a5OV[a\x04EV[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\x01\xA0a\x06>V[`@Qa\x01\x8F\x92\x91\x90a5\xEBV[a\x01\x85a\x01\xBC6`\x04a6\xD9V[a\x08\xA0V[a\x01\xD4a\x01\xCF6`\x04a7AV[a\n\xD7V[\0[a\x01\xE9a\x01\xE46`\x04a7\x9CV[a\x0C,V[`@Qa\x01\x8F\x95\x94\x93\x92\x91\x90a7\xB3V[a\x02\ra\x02\x086`\x04a7\x9CV[a\x0C\xFEV[`@Qa\x01\x8F\x98\x97\x96\x95\x94\x93\x92\x91\x90a7\xFBV[a\x01\xD4a\x02/6`\x04a7\x9CV[a\r\xEFV[a\x02Ua\x02B6`\x04a8PV[_T`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x91\x16\x14\x90V[`@Q\x90\x15\x15\x81R` \x01a\x01\x8FV[a\x01\xD4a\x02s6`\x04a8iV[a\x0E\xD4V[a\x02\x80a\x0F\xF0V[`@Qa\x01\x8F\x92\x91\x90a8\x9CV[a\x02\x96a\x11\xB4V[`@Qa\x01\x8F\x92\x91\x90a9+V[a\x02\xACa\x13\xBAV[`@Qa\x01\x8F\x92\x91\x90a9\xC3V[a\x01\xD4a\x02\xC86`\x04a7\x9CV[a\x16\x1DV[a\x01\xD4a\x02\xDB6`\x04a:\xB1V[a\x16\xC1V[a\x039a\x02\xEE6`\x04a7\x9CV[`\x02` \x81\x90R_\x91\x82R`@\x90\x91 \x80T`\x01\x82\x01T\x92\x82\x01T`\x03\x83\x01T`\x04\x84\x01T`\x05\x85\x01T`\x06\x90\x95\x01T\x93\x95\x94`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x94\x92\x93\x91\x82\x16\x92\x91\x16\x90\x87V[`@\x80Q\x97\x88R` \x88\x01\x96\x90\x96R`\x01`\x01`\xA0\x1B\x03\x94\x85\x16\x95\x87\x01\x95\x90\x95R``\x86\x01\x92\x90\x92R\x82\x16`\x80\x85\x01R\x16`\xA0\x83\x01R`\xC0\x82\x01R`\xE0\x01a\x01\x8FV[a\x01\xD4a\x03\x8A6`\x04a7\x9CV[a\x18]V[_T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01\x8FV[a\x01\x85aT`\x81V[a\x01\xD4a\x03\xC06`\x04a7\x9CV[a\x19@V[a\x04\x07a\x03\xD36`\x04a7\x9CV[`\x03` \x81\x90R_\x91\x82R`@\x90\x91 \x80T`\x01\x82\x01T`\x02\x83\x01T\x92\x90\x93\x01T\x90\x92`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x92\x91\x16\x84V[`@\x80Q\x94\x85R`\x01`\x01`\xA0\x1B\x03\x93\x84\x16` \x86\x01R\x84\x01\x91\x90\x91R\x16``\x82\x01R`\x80\x01a\x01\x8FV[a\x01\xD4a\x04@6`\x04a:\xB1V[a\x1ASV[_\x82\x81R`\x01` R`@\x81 \x80T\x83\x11\x15a\x04_W__\xFD[_\x83\x11a\x04jW__\xFD[\x80T`\x03\x82\x01T_\x91\x90a\x04~\x90\x86a;UV[a\x04\x88\x91\x90a;\x99V[\x90P_\x81\x11a\x04\x99Wa\x04\x99a;\xACV[\x80\x82`\x03\x01T\x10\x15a\x04\xADWa\x04\xADa;\xACV[\x80\x82`\x03\x01_\x82\x82Ta\x04\xC0\x91\x90a;\xD9V[\x90\x91UPP\x81T\x84\x90\x83\x90_\x90a\x04\xD8\x90\x84\x90a;\xD9V[\x90\x91UPP`@\x80Q`\xE0\x81\x01\x82R\x86\x81R` \x81\x01\x86\x90R`\x02\x84\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x92\x82\x01\x92\x90\x92R``\x81\x01\x83\x90R`\x04\x84\x01T\x90\x91\x16`\x80\x82\x01R_\x90`\xA0\x81\x01a\x05*a\x1B\xE0V[`\x01`\x01`\xA0\x1B\x03\x16\x81RB` \x90\x91\x01R`\x05\x80T\x91\x92P_\x91\x90\x82a\x05P\x83a;\xECV[\x90\x91UP_\x81\x81R`\x02` \x81\x81R`@\x92\x83\x90 \x86Q\x81U\x86\x82\x01Q`\x01\x82\x01U\x86\x84\x01Q\x81\x84\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x17\x90\x91U``\x80\x8A\x01Q`\x03\x85\x01U`\x80\x8A\x01Q`\x04\x85\x01\x80T\x84\x16\x91\x85\x16\x91\x90\x91\x17\x90U`\xA0\x8A\x01Q`\x05\x85\x01\x80T\x90\x93\x16\x90\x84\x16\x17\x90\x91U`\xC0\x89\x01Q`\x06\x90\x93\x01\x92\x90\x92U\x92\x89\x01T\x84Q\x8C\x81R\x92\x83\x01\x89\x90R\x90\x92\x16\x92\x81\x01\x92\x90\x92R\x91\x92P\x82\x91\x89\x91\x7F\xC3\x9A\x1A]\xDC\x0E\x85\xC9U\xFE.\x1A\xBE\xB4<\x94\xCE\x182.u\xBB=D\xE8\x0Fu\x9F\xF9\xD04\xB9\x91\x01`@Q\x80\x91\x03\x90\xA3\x93PPPP[\x92\x91PPV[``\x80_\x80[`\x05T\x81\x10\x15a\x06\x83W_\x81\x81R`\x01` R`@\x90 `\x04\x01T`\x01`\x01`\xA0\x1B\x03\x16\x15a\x06{W\x81a\x06w\x81a;\xECV[\x92PP[`\x01\x01a\x06DV[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\x9EWa\x06\x9Ea<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x06\xD7W\x81` \x01[a\x06\xC4a4eV[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x06\xBCW\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\xF4Wa\x06\xF4a<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x07\x1DW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x05T\x81\x10\x15a\x08\x94W_\x81\x81R`\x01` R`@\x90 `\x04\x01T`\x01`\x01`\xA0\x1B\x03\x16\x15a\x08\x8CW`\x01_\x82\x81R` \x01\x90\x81R` \x01_ `@Q\x80`\xA0\x01`@R\x90\x81_\x82\x01T\x81R` \x01`\x01\x82\x01`@Q\x80` \x01`@R\x90\x81_\x82\x01\x80Ta\x07\x90\x90a<1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07\xBC\x90a<1V[\x80\x15a\x08\x07W\x80`\x1F\x10a\x07\xDEWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x08\x07V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\xEAW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP\x81R`\x02\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16` \x83\x01R`\x03\x83\x01T`@\x83\x01R`\x04\x90\x92\x01T\x90\x91\x16``\x90\x91\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x08UWa\x08Ua<|V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x08sWa\x08sa<|V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x08\x88\x81a;\xECV[\x92PP[`\x01\x01a\x07#V[P\x91\x95\x90\x94P\x92PPPV[_\x83\x81R`\x03` R`@\x81 \x82a\x08\xB6W__\xFD[\x80T\x83\x11\x15a\x08\xC3W__\xFD[\x80T`\x02\x82\x01T_\x91\x90a\x08\xD7\x90\x86a;UV[a\x08\xE1\x91\x90a;\x99V[\x90P_\x81\x11a\x08\xF2Wa\x08\xF2a;\xACV[\x80\x82`\x02\x01T\x10\x15a\t\x06Wa\t\x06a;\xACV[\x80\x82`\x02\x01_\x82\x82Ta\t\x19\x91\x90a;\xD9V[\x90\x91UPP\x81T\x84\x90\x83\x90_\x90a\t1\x90\x84\x90a;\xD9V[\x90\x91UPa\tX\x90Pa\tBa\x1B\xE0V[`\x01\x84\x01T`\x01`\x01`\xA0\x1B\x03\x16\x900\x84a\x1C0V[`\x05\x80T_\x91\x82a\th\x83a;\xECV[\x91\x90PU\x90P`@Q\x80a\x01\0\x01`@R\x80\x88\x81R` \x01\x87a\t\x8A\x90a=]V[\x81R` \x81\x01\x87\x90R`\x01\x85\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`@\x83\x01R``\x82\x01\x85\x90R`\x03\x86\x01T\x16`\x80\x82\x01R`\xA0\x01a\t\xC5a\x1B\xE0V[`\x01`\x01`\xA0\x1B\x03\x16\x81RB` \x91\x82\x01R_\x83\x81R`\x04\x82R`@\x90 \x82Q\x81U\x90\x82\x01Q\x80Q`\x01\x83\x01\x90\x81\x90a\t\xFE\x90\x82a>\x02V[PPP`@\x82\x81\x01Q`\x02\x83\x01U``\x83\x01Q`\x03\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x17\x90\x91U`\x80\x85\x01Q`\x04\x85\x01U`\xA0\x85\x01Q`\x05\x85\x01\x80T\x83\x16\x91\x84\x16\x91\x90\x91\x17\x90U`\xC0\x85\x01Q`\x06\x85\x01\x80T\x90\x92\x16\x90\x83\x16\x17\x90U`\xE0\x90\x93\x01Q`\x07\x90\x92\x01\x91\x90\x91U`\x01\x85\x01T\x90Q\x83\x92\x8A\x92\x7Fe>\r\x81\xF2\xC9\x9B\xEB\xA3Y\xDF\xB1{I\x9A\\\xFF+\xE9\xD9PQHR\"M\xF8\xC0\x97\xC2\x19!\x92a\n\xC3\x92\x8C\x92\x8C\x92\x8A\x92\x91\x90\x91\x16\x90a?TV[`@Q\x80\x91\x03\x90\xA3\x92PPP[\x93\x92PPPV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\n\xE9W__\xFD[a\x0B\x06a\n\xF4a\x1B\xE0V[`\x01`\x01`\xA0\x1B\x03\x84\x16\x900\x84a\x1C0V[`\x05\x80T_\x91\x82a\x0B\x16\x83a;\xECV[\x91\x90PU\x90P`@Q\x80`\xA0\x01`@R\x80\x86\x81R` \x01\x85a\x0B7\x90a=]V[\x81R` \x01\x84`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x83\x81R` \x01a\x0BYa\x1B\xE0V[`\x01`\x01`\xA0\x1B\x03\x16\x90R_\x82\x81R`\x01` \x81\x81R`@\x90\x92 \x83Q\x81U\x91\x83\x01Q\x80Q\x90\x91\x83\x01\x90\x81\x90a\x0B\x8F\x90\x82a>\x02V[PPP`@\x82\x81\x01Q`\x02\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x17\x90\x91U``\x85\x01Q`\x03\x85\x01U`\x80\x90\x94\x01Q`\x04\x90\x93\x01\x80T\x90\x94\x16\x92\x16\x91\x90\x91\x17\x90\x91UQ\x7F\x98\xC7\xC6\x80@=G@=\xEAJW\r\x0ElW\x16S\x8CIB\x0E\xF4q\xCE\xC4(\xF5\xA5\x85,\x06\x90a\x0C\x1D\x90\x87\x90\x87\x90\x87\x90\x87\x90a?\x8BV[`@Q\x80\x91\x03\x90\xA1PPPPPV[`\x01` \x81\x81R_\x92\x83R`@\x92\x83\x90 \x80T\x84Q\x92\x83\x01\x90\x94R\x91\x82\x01\x80T\x82\x90\x82\x90a\x0CY\x90a<1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C\x85\x90a<1V[\x80\x15a\x0C\xD0W\x80`\x1F\x10a\x0C\xA7Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C\xD0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0C\xB3W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP`\x02\x82\x01T`\x03\x83\x01T`\x04\x90\x93\x01T\x91\x92`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x92\x90\x91\x16\x85V[`\x04` R\x80_R`@_ _\x91P\x90P\x80_\x01T\x90\x80`\x01\x01`@Q\x80` \x01`@R\x90\x81_\x82\x01\x80Ta\r2\x90a<1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r^\x90a<1V[\x80\x15a\r\xA9W\x80`\x1F\x10a\r\x80Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\r\xA9V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r\x8CW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP`\x02\x82\x01T`\x03\x83\x01T`\x04\x84\x01T`\x05\x85\x01T`\x06\x86\x01T`\x07\x90\x96\x01T\x94\x95\x93\x94`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x94\x92\x93\x91\x82\x16\x92\x90\x91\x16\x90\x88V[_\x81\x81R`\x01` R`@\x90 a\x0E\x04a\x1B\xE0V[`\x04\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x0E\x1FW__\xFD[a\x0EDa\x0E*a\x1B\xE0V[`\x03\x83\x01T`\x02\x84\x01T`\x01`\x01`\xA0\x1B\x03\x16\x91\x90a\x1C\xE7V[_\x82\x81R`\x01` \x81\x90R`@\x82 \x82\x81U\x91\x90\x82\x01\x81a\x0Ee\x82\x82a4\xA6V[PPP`\x02\x81\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U_`\x03\x83\x01U`\x04\x90\x91\x01\x80T\x90\x91\x16\x90U`@Q\x82\x81R\x7F\xC3@\xE7\xACH\xDC\x80\xEEy?\xC6&i`\xBD_\x1B\xD2\x1B\xE9\x1C\x8A\x95\xE2\x18\x17\x81\x13\xF7\x9E\x17\xB4\x90` \x01[`@Q\x80\x91\x03\x90\xA1PPV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x0E\xE6W__\xFD[_\x83\x11a\x0E\xF1W__\xFD[_\x81\x11a\x0E\xFCW__\xFD[`\x05\x80T_\x91\x82a\x0F\x0C\x83a;\xECV[\x91\x90PU\x90P`@Q\x80`\x80\x01`@R\x80\x85\x81R` \x01\x84`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x83\x81R` \x01a\x0F@a\x1B\xE0V[`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x90\x91R_\x83\x81R`\x03` \x81\x81R`@\x92\x83\x90 \x85Q\x81U\x85\x82\x01Q`\x01\x82\x01\x80T\x91\x87\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x92\x83\x16\x17\x90U\x86\x85\x01Q`\x02\x83\x01U``\x96\x87\x01Q\x91\x90\x93\x01\x80T\x91\x86\x16\x91\x90\x93\x16\x17\x90\x91U\x81Q\x88\x81R\x92\x87\x16\x90\x83\x01R\x81\x01\x84\x90R\x82\x91\x7F\xFF\x1C\xE2\x10\xDE\xFC\xD3\xBA\x1A\xDFv\xC9A\x9A\x07X\xFA`\xFD>\xB3\x8C{\xD9A\x8F`\xB5u\xB7n$\x91\x01`@Q\x80\x91\x03\x90\xA2PPPPV[``\x80_\x80[`\x05T\x81\x10\x15a\x106W_\x81\x81R`\x03` \x81\x90R`@\x90\x91 \x01T`\x01`\x01`\xA0\x1B\x03\x16\x15a\x10.W\x81a\x10*\x81a;\xECV[\x92PP[`\x01\x01a\x0F\xF6V[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10QWa\x10Qa<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x10\xA1W\x81` \x01[`@\x80Q`\x80\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x92\x82\x01\x81\x90R``\x82\x01R\x82R_\x19\x90\x92\x01\x91\x01\x81a\x10oW\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10\xBEWa\x10\xBEa<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x10\xE7W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x05T\x81\x10\x15a\x08\x94W_\x81\x81R`\x03` \x81\x90R`@\x90\x91 \x01T`\x01`\x01`\xA0\x1B\x03\x16\x15a\x11\xACW_\x81\x81R`\x03` \x81\x81R`@\x92\x83\x90 \x83Q`\x80\x81\x01\x85R\x81T\x81R`\x01\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x93\x82\x01\x93\x90\x93R`\x02\x82\x01T\x94\x81\x01\x94\x90\x94R\x90\x91\x01T\x16``\x82\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x11uWa\x11ua<|V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x11\x93Wa\x11\x93a<|V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x11\xA8\x81a;\xECV[\x92PP[`\x01\x01a\x10\xEDV[``\x80_\x80[`\x05T\x81\x10\x15a\x11\xF0W_\x81\x81R`\x02` R`@\x90 `\x01\x01T\x15a\x11\xE8W\x81a\x11\xE4\x81a;\xECV[\x92PP[`\x01\x01a\x11\xBAV[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\x0BWa\x12\x0Ba<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x12\x90W\x81` \x01[a\x12}`@Q\x80`\xE0\x01`@R\x80_\x81R` \x01_\x81R` \x01_`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01_\x81R` \x01_`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01_`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01_\x81RP\x90V[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x12)W\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\xADWa\x12\xADa<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x12\xD6W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x05T\x81\x10\x15a\x08\x94W_\x81\x81R`\x02` R`@\x90 `\x01\x01T\x15a\x13\xB2W_\x81\x81R`\x02` \x81\x81R`@\x92\x83\x90 \x83Q`\xE0\x81\x01\x85R\x81T\x81R`\x01\x82\x01T\x92\x81\x01\x92\x90\x92R\x91\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x93\x82\x01\x93\x90\x93R`\x03\x82\x01T``\x82\x01R`\x04\x82\x01T\x83\x16`\x80\x82\x01R`\x05\x82\x01T\x90\x92\x16`\xA0\x83\x01R`\x06\x01T`\xC0\x82\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x13{Wa\x13{a<|V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x13\x99Wa\x13\x99a<|V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x13\xAE\x81a;\xECV[\x92PP[`\x01\x01a\x12\xDCV[``\x80_\x80[`\x05T\x81\x10\x15a\x13\xF6W_\x81\x81R`\x04` R`@\x90 `\x02\x01T\x15a\x13\xEEW\x81a\x13\xEA\x81a;\xECV[\x92PP[`\x01\x01a\x13\xC0V[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x14\x11Wa\x14\x11a<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x14JW\x81` \x01[a\x147a4\xE0V[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x14/W\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x14gWa\x14ga<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x14\x90W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x05T\x81\x10\x15a\x08\x94W_\x81\x81R`\x04` R`@\x90 `\x02\x01T\x15a\x16\x15W`\x04_\x82\x81R` \x01\x90\x81R` \x01_ `@Q\x80a\x01\0\x01`@R\x90\x81_\x82\x01T\x81R` \x01`\x01\x82\x01`@Q\x80` \x01`@R\x90\x81_\x82\x01\x80Ta\x14\xFB\x90a<1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x15'\x90a<1V[\x80\x15a\x15rW\x80`\x1F\x10a\x15IWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x15rV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15UW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP\x81R`\x02\x82\x01T` \x82\x01R`\x03\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`@\x83\x01R`\x04\x83\x01T``\x83\x01R`\x05\x83\x01T\x81\x16`\x80\x83\x01R`\x06\x83\x01T\x16`\xA0\x82\x01R`\x07\x90\x91\x01T`\xC0\x90\x91\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x15\xDEWa\x15\xDEa<|V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x15\xFCWa\x15\xFCa<|V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x16\x11\x81a;\xECV[\x92PP[`\x01\x01a\x14\x96V[_\x81\x81R`\x03` R`@\x90 a\x162a\x1B\xE0V[`\x03\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x16MW__\xFD[_\x82\x81R`\x03` \x81\x81R`@\x80\x84 \x84\x81U`\x01\x81\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U`\x02\x82\x01\x95\x90\x95U\x90\x92\x01\x80T\x90\x93\x16\x90\x92UQ\x83\x81R\x7F<\xD4u\xB0\x92\xE8\xB3y\xF6\xBA\r\x9E\x0E\x0C\x8F0p^s2\x1D\xC5\xC9\xF8\x0C\xE4\xAD8\xDB{\xE1\xAA\x91\x01a\x0E\xC8V[_\x83\x81R`\x02` R`@\x90 a\x16\xD6a\x1B\xE0V[`\x05\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x16\xF1W__\xFD[`\x06T`\x01`\x01`\xA0\x1B\x03\x16c\xD3\x8C)\xA1a\x17\x0F`@\x85\x01\x85a?\xBFV[`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x17,\x92\x91\x90a@ V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x17CW__\xFD[PZ\xF1\x15\x80\x15a\x17UW=__>=_\xFD[PPPPa\x17\x86`\x07T\x84a\x17i\x90a@bV[a\x17r\x85aA\x10V[`\x06T`\x01`\x01`\xA0\x1B\x03\x16\x92\x91\x90a\x1D5V[P\x80T_\x90\x81R`\x01` \x81\x90R`@\x90\x91 \x80T\x90\x91a\x17\xAA\x91\x90\x83\x01\x86a\x1DbV[`\x05\x82\x01T`\x03\x83\x01T`\x02\x84\x01Ta\x17\xD1\x92`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x92\x91\x16\x90a\x1C\xE7V[_\x85\x81R`\x02` \x81\x81R`@\x80\x84 \x84\x81U`\x01\x81\x01\x85\x90U\x92\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U`\x03\x84\x01\x85\x90U`\x04\x84\x01\x80T\x82\x16\x90U`\x05\x84\x01\x80T\x90\x91\x16\x90U`\x06\x90\x92\x01\x92\x90\x92UQ\x86\x81R\x7F\xB4\xC9\x8D\xE2\x10ik<\xF2\x1E\x993\\\x1E\xE3\xA0\xAE4\xA2g\x13A*J\xDD\xE8\xAFYav\xF3~\x91\x01a\x0C\x1DV[_\x81\x81R`\x02` R`@\x90 a\x18ra\x1B\xE0V[`\x04\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x18\x8DW__\xFD[aT`\x81`\x06\x01Ta\x18\x9F\x91\x90aA\xBDV[B\x11a\x18\xA9W__\xFD[a\x18\xB4a\x0E*a\x1B\xE0V[_\x82\x81R`\x02` \x81\x81R`@\x80\x84 \x84\x81U`\x01\x81\x01\x85\x90U\x92\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U`\x03\x84\x01\x85\x90U`\x04\x84\x01\x80T\x82\x16\x90U`\x05\x84\x01\x80T\x90\x91\x16\x90U`\x06\x90\x92\x01\x92\x90\x92UQ\x83\x81R\x7F>^\xA3X\xE9\xEBL\xDFD\xCD\xC7y8\xAD\xE8\x07K\x12@\xA6\xD8\xC0\xFD\x13r\x86q\xB8.\x80\n\xD6\x91\x01a\x0E\xC8V[_\x81\x81R`\x04` R`@\x90 `\x07\x81\x01Ta\x19_\x90aT`\x90aA\xBDV[B\x11a\x19iW__\xFD[a\x19qa\x1B\xE0V[`\x06\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x19\x8CW__\xFD[a\x19\xB1a\x19\x97a\x1B\xE0V[`\x04\x83\x01T`\x03\x84\x01T`\x01`\x01`\xA0\x1B\x03\x16\x91\x90a\x1C\xE7V[_\x82\x81R`\x04` R`@\x81 \x81\x81U\x90`\x01\x82\x01\x81a\x19\xD1\x82\x82a4\xA6V[PP_`\x02\x83\x01\x81\x90U`\x03\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U`\x04\x84\x01\x82\x90U`\x05\x84\x01\x80T\x82\x16\x90U`\x06\x84\x01\x80T\x90\x91\x16\x90U`\x07\x90\x92\x01\x91\x90\x91UP`@Q\x82\x81R\x7Fx\xF5\x1Fb\xF7\xCF\x13\x81\xC6s\xC2~\xAE\x18}\xD6\xC5\x88\xDCf$\xCEYi}\xBB>\x1D|\x1B\xBC\xDF\x90` \x01a\x0E\xC8V[_\x83\x81R`\x04` R`@\x90 a\x1Aha\x1B\xE0V[`\x05\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x1A\x83W__\xFD[`\x06T`\x01`\x01`\xA0\x1B\x03\x16c\xD3\x8C)\xA1a\x1A\xA1`@\x85\x01\x85a?\xBFV[`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1A\xBE\x92\x91\x90a@ V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1A\xD5W__\xFD[PZ\xF1\x15\x80\x15a\x1A\xE7W=__>=_\xFD[PPPPa\x1A\xFB`\x07T\x84a\x17i\x90a@bV[Pa\x1B\x0E\x81`\x02\x01T\x82`\x01\x01\x85a\x1DbV[`\x05\x81\x01T`\x04\x82\x01T`\x03\x83\x01Ta\x1B5\x92`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x92\x91\x16\x90a\x1C\xE7V[_\x84\x81R`\x04` R`@\x81 \x81\x81U\x90`\x01\x82\x01\x81a\x1BU\x82\x82a4\xA6V[PP_`\x02\x83\x01\x81\x90U`\x03\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U`\x04\x84\x01\x82\x90U`\x05\x84\x01\x80T\x82\x16\x90U`\x06\x84\x01\x80T\x90\x91\x16\x90U`\x07\x90\x92\x01\x91\x90\x91UP`@Q\x84\x81R\x7F\xCFV\x10a\xDBx\xF7\xBCQ\x8D7\xFE\x86q\x85\x14\xC6@\xCC\xC5\xC3\xF1)8(\xB9U\xE6\x8F\x19\xF5\xFB\x90` \x01`@Q\x80\x91\x03\x90\xA1PPPPV[_`\x146\x10\x80\x15\x90a\x1B\xFBWP_T`\x01`\x01`\xA0\x1B\x03\x163\x14[\x15a\x1C+WP\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xEC6\x015``\x1C\x90V[P3\x90V[`@Q`\x01`\x01`\xA0\x1B\x03\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x1C\xE1\x90\x85\x90\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\x90`\x84\x01[`@\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\x1EyV[PPPPV[`@Q`\x01`\x01`\xA0\x1B\x03\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x1D0\x90\x84\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\x90`d\x01a\x1C}V[PPPV[_a\x1D?\x83a\x1F]V[\x90Pa\x1DK\x81\x83a MV[a\x1DZ\x85\x85\x84`@\x01Qa\"\xB1V[\x94\x93PPPPV[_\x82_\x01\x80Ta\x1Dq\x90a<1V[`@Qa\x1D\x83\x92P\x85\x90` \x01aA\xD0V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P_a\x1D\xEA\x83\x80`@\x01\x90a\x1D\xAF\x91\x90a?\xBFV[\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\x91RP\x86\x92Pa&\x01\x91PPV[Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x84\x81\x10\x15a\x1ErW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`;`$\x82\x01R\x7FBitcoin transaction amount is lo`D\x82\x01R\x7Fwer than in accepted order.\0\0\0\0\0`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[PPPPPV[_a\x1E\xCD\x82`@Q\x80`@\x01`@R\x80` \x81R` \x01\x7FSafeERC20: low-level call failed\x81RP\x85`\x01`\x01`\xA0\x1B\x03\x16a'\x9F\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x1D0W\x80\x80` \x01\x90Q\x81\x01\x90a\x1E\xEB\x91\x90aB\x97V[a\x1D0W`@QbF\x1B\xCD`\xE5\x1B\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\x1EiV[_a\x1Fk\x82` \x01Qa'\xADV[a\x1F\xB7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FInvalid input vector provided\0\0\0`D\x82\x01R`d\x01a\x1EiV[a\x1F\xC4\x82`@\x01Qa(GV[a \x10W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FInvalid output vector provided\0\0`D\x82\x01R`d\x01a\x1EiV[a\x068\x82_\x01Q\x83` \x01Q\x84`@\x01Q\x85``\x01Q`@Q` \x01a 9\x94\x93\x92\x91\x90aB\xCDV[`@Q` \x81\x83\x03\x03\x81R\x90`@Ra(\xD4V[\x80Qa X\x90a(\xF6V[a \xA4W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7FBad merkle array proof\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x1EiV[`\x80\x81\x01QQ\x81QQ\x14a! W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`/`$\x82\x01R\x7FTx not on same level of merkle t`D\x82\x01R\x7Free as coinbase\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x1EiV[_a!.\x82`@\x01Qa)\x0CV[\x82Q` \x84\x01Q\x91\x92Pa!E\x91\x85\x91\x84\x91a)\x18V[a!\xB7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`<`$\x82\x01R\x7FTx merkle proof is not valid for`D\x82\x01R\x7F provided header and tx hash\0\0\0\0`d\x82\x01R`\x84\x01a\x1EiV[_`\x02\x83``\x01Q`@Q` \x01a!\xD1\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra!\xEB\x91aC=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\")\x91\x90aCGV[`\x80\x84\x01Q\x90\x91Pa\"?\x90\x82\x90\x84\x90_a)\x18V[a\x1C\xE1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`?`$\x82\x01R\x7FCoinbase merkle proof is not val`D\x82\x01R\x7Fid for provided header and hash\0`d\x82\x01R`\x84\x01a\x1EiV[_\x83`\x01`\x01`\xA0\x1B\x03\x16c\x117d\xBE`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\"\xEEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a#\x12\x91\x90aCGV[\x90P_\x84`\x01`\x01`\xA0\x1B\x03\x16c+\x97\xBE$`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a#QW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a#u\x91\x90aCGV[\x90P_\x80a#\x8Aa#\x85\x86a)SV[a)^V[\x90P\x83\x81\x03a#\x9BW\x83\x91Pa$\x18V[\x82\x81\x03a#\xAAW\x82\x91Pa$\x18V[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`%`$\x82\x01R\x7FNot at current or previous diffi`D\x82\x01R\x7Fculty\0\0\0\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\x1EiV[_a$\"\x86a)\x85V[\x90P_\x19\x81\x03a$\x9AW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`#`$\x82\x01R\x7FInvalid length of the headers ch`D\x82\x01R\x7Fain\0\0\0\0\0\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\x1EiV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81\x03a%\tW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FInvalid headers chain\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x1EiV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFD\x81\x03a%xW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FInsufficient work in a header\0\0\0`D\x82\x01R`d\x01a\x1EiV[a%\x82\x87\x84a;UV[\x81\x10\x15a%\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FInsufficient accumulated difficu`D\x82\x01R\x7Flty in header chain\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x1EiV[PPPPPPPPV[`@\x80Q``\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x82\x84\x01\x82\x90R\x83Q\x80\x85\x01\x90\x94R\x81\x84R\x83\x01R\x90a&5\x84a+\xA9V[` \x83\x01R\x80\x82R\x81a&G\x82a;\xECV[\x90RP_\x80[\x82` \x01Q\x81\x10\x15a'IW\x82Q_\x90a&h\x90\x88\x90a+\xBEV[\x84Q\x90\x91P_\x90a&z\x90\x89\x90a,\x1EV[\x90P_a&\x88`\x08\x84a;\xD9V[\x86Q\x90\x91P_\x90a&\x9A\x90`\x08aA\xBDV[\x8A\x81\x01` \x01\x83\x90 \x90\x91P\x80\x8A\x03a&\xD4W`\x01\x96P\x83\x89_\x01\x81\x81Qa&\xC2\x91\x90aC^V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RPa'$V[_a&\xE2\x8C\x8A_\x01Qa,\x94V[\x90P`\x01`\x01`\xA0\x1B\x03\x81\x16\x15a'\x03W`\x01`\x01`\xA0\x1B\x03\x81\x16` \x8B\x01R[_a'\x11\x8D\x8B_\x01Qa-tV[\x90P\x80\x15a'!W`@\x8B\x01\x81\x90R[PP[\x84\x88_\x01\x81\x81Qa'5\x91\x90aA\xBDV[\x90RPP`\x01\x90\x94\x01\x93Pa&M\x92PPPV[P\x80a'\x97W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FNo output found for scriptPubKey`D\x82\x01R`d\x01a\x1EiV[PP\x92\x91PPV[``a\x1DZ\x84\x84_\x85a.TV[___a'\xB9\x84a+\xA9V[\x90\x92P\x90P\x80\x15\x80a'\xCBWP_\x19\x82\x14[\x15a'\xD9WP_\x93\x92PPPV[_a'\xE5\x83`\x01aA\xBDV[\x90P_[\x82\x81\x10\x15a(:W\x85Q\x82\x10a(\x04WP_\x95\x94PPPPPV[_a(\x0F\x87\x84a/\x98V[\x90P_\x19\x81\x03a(%WP_\x96\x95PPPPPPV[a(/\x81\x84aA\xBDV[\x92PP`\x01\x01a'\xE9V[P\x93Q\x90\x93\x14\x93\x92PPPV[___a(S\x84a+\xA9V[\x90\x92P\x90P\x80\x15\x80a(eWP_\x19\x82\x14[\x15a(sWP_\x93\x92PPPV[_a(\x7F\x83`\x01aA\xBDV[\x90P_[\x82\x81\x10\x15a(:W\x85Q\x82\x10a(\x9EWP_\x95\x94PPPPPV[_a(\xA9\x87\x84a+\xBEV[\x90P_\x19\x81\x03a(\xBFWP_\x96\x95PPPPPPV[a(\xC9\x81\x84aA\xBDV[\x92PP`\x01\x01a(\x83V[_` _\x83Q` \x85\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x91\x90PV[_` \x82Qa)\x05\x91\x90aC~V[\x15\x92\x91PPV[`D\x81\x01Q_\x90a\x068V[_\x83\x85\x14\x80\x15a)&WP\x81\x15[\x80\x15a)1WP\x82Q\x15[\x15a)>WP`\x01a\x1DZV[a)J\x85\x84\x86\x85a/\xDEV[\x95\x94PPPPPV[_a\x068\x82_a0\x83V[_a\x068{\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\x83a1\x1CV[_`P\x82Qa)\x94\x91\x90aC~V[\x15a)\xA1WP_\x19\x91\x90PV[P_\x80\x80[\x83Q\x81\x10\x15a+\xA2W\x80\x15a)\xEDWa)\xC0\x84\x82\x84a1'V[a)\xEDWP\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x93\x92PPPV[_a)\xF8\x85\x83a0\x83V[\x90Pa*\x06\x85\x83`Pa1PV[\x92P\x80a+I\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a+yWP\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFD\x94\x93PPPPV[a+\x82\x81a)^V[a+\x8C\x90\x85aA\xBDV[\x93Pa+\x9B\x90P`P\x82aA\xBDV[\x90Pa)\xA6V[PP\x91\x90PV[__a+\xB5\x83_a1uV[\x91P\x91P\x91P\x91V[_a+\xCA\x82`\taA\xBDV[\x83Q\x10\x15a+\xDAWP_\x19a\x068V[_\x80a+\xF0\x85a+\xEB\x86`\x08aA\xBDV[a1uV[\x90\x92P\x90P`\x01\x82\x01a,\x08W_\x19\x92PPPa\x068V[\x80a,\x14\x83`\taA\xBDV[a)J\x91\x90aA\xBDV[_\x80a,*\x84\x84a3\x12V[`\xC0\x1C\x90P_a)J\x82d\xFF\0\0\0\xFF`\x08\x82\x81\x1C\x91\x82\x16e\xFF\0\0\0\xFF\0\x93\x90\x91\x1B\x92\x83\x16\x17`\x10\x90\x81\x1Bg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16f\xFF\0\xFF\0\xFF\0\xFF\x92\x90\x92\x16g\xFF\0\xFF\0\xFF\0\xFF\0\x90\x93\x16\x92\x90\x92\x17\x90\x91\x1Ce\xFF\xFF\0\0\xFF\xFF\x16\x17` \x81\x81\x1C\x91\x90\x1B\x17\x90V[_\x82a,\xA1\x83`\taA\xBDV[\x81Q\x81\x10a,\xB1Wa,\xB1a<|V[` \x91\x01\x01Q\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\x16\x7Fj\0\0\0\0\0\0\0\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-\x06WP_a\x068V[_\x83a-\x13\x84`\naA\xBDV[\x81Q\x81\x10a-#Wa-#a<|V[\x01` \x01Q\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\x81\x16\x91P`\xF8\x1C`\x14\x03a-mW_a-c\x84`\x0BaA\xBDV[\x85\x01`\x14\x01Q\x92PP[P\x92\x91PPV[_\x82a-\x81\x83`\taA\xBDV[\x81Q\x81\x10a-\x91Wa-\x91a<|V[` \x91\x01\x01Q\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\x16\x7Fj\0\0\0\0\0\0\0\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-\xE6WP_a\x068V[_\x83a-\xF3\x84`\naA\xBDV[\x81Q\x81\x10a.\x03Wa.\x03a<|V[\x01` \x90\x81\x01Q\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\x81\x16\x92P`\xF8\x1C\x90\x03a-mW_a.D\x84`\x0BaA\xBDV[\x85\x01` \x01Q\x92PPP\x92\x91PPV[``\x82G\x10\x15a.\xCCW`@QbF\x1B\xCD`\xE5\x1B\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\x1EiV[`\x01`\x01`\xA0\x1B\x03\x85\x16;a/#W`@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\x1EiV[__\x86`\x01`\x01`\xA0\x1B\x03\x16\x85\x87`@Qa/>\x91\x90aCa/}V[``\x91P[P\x91P\x91Pa/\x8D\x82\x82\x86a3 V[\x97\x96PPPPPPPV[___a/\xA5\x85\x85a3YV[\x90\x92P\x90P`\x01\x82\x01a/\xBDW_\x19\x92PPPa\x068V[\x80a/\xC9\x83`%aA\xBDV[a/\xD3\x91\x90aA\xBDV[a)J\x90`\x04aA\xBDV[_` \x84Qa/\xED\x91\x90aC~V[\x15a/\xF9WP_a\x1DZV[\x83Q_\x03a0\x08WP_a\x1DZV[\x81\x85_[\x86Q\x81\x10\x15a0vWa0 `\x02\x84aC~V[`\x01\x03a0DWa0=a07\x88\x83\x01` \x01Q\x90V[\x83a3\x97V[\x91Pa0]V[a0Z\x82a0U\x89\x84\x01` \x01Q\x90V[a3\x97V[\x91P[`\x01\x92\x90\x92\x1C\x91a0o` \x82aA\xBDV[\x90Pa0\x0CV[P\x90\x93\x14\x95\x94PPPPPV[_\x80a0\x9Aa0\x93\x84`HaA\xBDV[\x85\x90a3\x12V[`\xE8\x1C\x90P_\x84a0\xAC\x85`KaA\xBDV[\x81Q\x81\x10a0\xBCWa0\xBCa<|V[\x01` \x01Q`\xF8\x1C\x90P_a0\xEE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a1\x01`\x03\x84aC\x91V[`\xFF\x16\x90Pa1\x12\x81a\x01\0aD\x8DV[a/\x8D\x90\x83a;UV[_a\n\xD0\x82\x84a;\x99V[_\x80a13\x85\x85a3\xA2V[\x90P\x82\x81\x14a1EW_\x91PPa\n\xD0V[P`\x01\x94\x93PPPPV[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[___a1\x82\x85\x85a3\xBAV[\x90P\x80`\xFF\x16_\x03a1\xB5W_\x85\x85\x81Q\x81\x10a1\xA1Wa1\xA1a<|V[\x01` \x01Q\x90\x93P`\xF8\x1C\x91Pa3\x0B\x90PV[\x83a1\xC1\x82`\x01aD\x98V[`\xFF\x16a1\xCE\x91\x90aA\xBDV[\x85Q\x10\x15a1\xE3W_\x19_\x92P\x92PPa3\x0BV[_\x81`\xFF\x16`\x02\x03a2&Wa2\x1Ba2\x07a2\0\x87`\x01aA\xBDV[\x88\x90a3\x12V[b\xFF\xFF\0`\xE8\x82\x90\x1C\x16`\xF8\x91\x90\x91\x1C\x17\x90V[a\xFF\xFF\x16\x90Pa3\x01V[\x81`\xFF\x16`\x04\x03a2uWa2ha2Ba2\0\x87`\x01aA\xBDV[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[c\xFF\xFF\xFF\xFF\x16\x90Pa3\x01V[\x81`\xFF\x16`\x08\x03a3\x01Wa2\xF4a2\x91a2\0\x87`\x01aA\xBDV[`\xC0\x1Cd\xFF\0\0\0\xFF`\x08\x82\x81\x1C\x91\x82\x16e\xFF\0\0\0\xFF\0\x93\x90\x91\x1B\x92\x83\x16\x17`\x10\x90\x81\x1Bg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16f\xFF\0\xFF\0\xFF\0\xFF\x92\x90\x92\x16g\xFF\0\xFF\0\xFF\0\xFF\0\x90\x93\x16\x92\x90\x92\x17\x90\x91\x1Ce\xFF\xFF\0\0\xFF\xFF\x16\x17` \x81\x81\x1C\x91\x90\x1B\x17\x90V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P[`\xFF\x90\x91\x16\x92P\x90P[\x92P\x92\x90PV[_a\n\xD0\x83\x83\x01` \x01Q\x90V[``\x83\x15a3/WP\x81a\n\xD0V[\x82Q\x15a3?W\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x1Ei\x91\x90aD\xB1V[_\x80a3f\x83`%aA\xBDV[\x84Q\x10\x15a3yWP_\x19\x90P_a3\x0BV[_\x80a3\x8A\x86a+\xEB\x87`$aA\xBDV[\x90\x97\x90\x96P\x94PPPPPV[_a\n\xD0\x83\x83a4>V[_a\n\xD0a3\xB1\x83`\x04aA\xBDV[\x84\x01` \x01Q\x90V[_\x82\x82\x81Q\x81\x10a3\xCDWa3\xCDa<|V[\x01` \x01Q`\xF8\x1C`\xFF\x03a3\xE4WP`\x08a\x068V[\x82\x82\x81Q\x81\x10a3\xF6Wa3\xF6a<|V[\x01` \x01Q`\xF8\x1C`\xFE\x03a4\rWP`\x04a\x068V[\x82\x82\x81Q\x81\x10a4\x1FWa4\x1Fa<|V[\x01` \x01Q`\xF8\x1C`\xFD\x03a46WP`\x02a\x068V[P_\x92\x91PPV[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[`@Q\x80`\xA0\x01`@R\x80_\x81R` \x01a4\x8C`@Q\x80` \x01`@R\x80``\x81RP\x90V[\x81R_` \x82\x01\x81\x90R`@\x82\x01\x81\x90R``\x90\x91\x01R\x90V[P\x80Ta4\xB2\x90a<1V[_\x82U\x80`\x1F\x10a4\xC1WPPV[`\x1F\x01` \x90\x04\x90_R` _ \x90\x81\x01\x90a4\xDD\x91\x90a57V[PV[`@Q\x80a\x01\0\x01`@R\x80_\x81R` \x01a5\x08`@Q\x80` \x01`@R\x80``\x81RP\x90V[\x81R_` \x82\x01\x81\x90R`@\x82\x01\x81\x90R``\x82\x01\x81\x90R`\x80\x82\x01\x81\x90R`\xA0\x82\x01\x81\x90R`\xC0\x90\x91\x01R\x90V[[\x80\x82\x11\x15a5KW_\x81U`\x01\x01a58V[P\x90V[__`@\x83\x85\x03\x12\x15a5`W__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_\x81Q` \x84Ra\x1DZ` \x85\x01\x82a5oV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a5\xE1W\x81Q\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a5\xC3V[P\x93\x94\x93PPPPV[_`@\x82\x01`@\x83R\x80\x85Q\x80\x83R``\x85\x01\x91P``\x81`\x05\x1B\x86\x01\x01\x92P` \x87\x01_[\x82\x81\x10\x15a6\xADW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x87\x86\x03\x01\x84R\x81Q\x80Q\x86R` \x81\x01Q`\xA0` \x88\x01Ra6_`\xA0\x88\x01\x82a5\x9DV[\x90P`\x01`\x01`\xA0\x1B\x03`@\x83\x01Q\x16`@\x88\x01R``\x82\x01Q``\x88\x01R`\x01`\x01`\xA0\x1B\x03`\x80\x83\x01Q\x16`\x80\x88\x01R\x80\x96PPP` \x82\x01\x91P` \x84\x01\x93P`\x01\x81\x01\x90Pa6\x11V[PPPP\x82\x81\x03` \x84\x01Ra)J\x81\x85a5\xB1V[_` \x82\x84\x03\x12\x15a6\xD3W__\xFD[P\x91\x90PV[___``\x84\x86\x03\x12\x15a6\xEBW__\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a7\x08W__\xFD[a7\x14\x86\x82\x87\x01a6\xC3V[\x93\x96\x93\x95PPPP`@\x91\x90\x91\x015\x90V[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a7\x1CWa>\x1Ca<\x04V[a>0\x81a>*\x84Ta<1V[\x84a=\xBEV[` `\x1F\x82\x11`\x01\x81\x14a>bW_\x83\x15a>KWP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x1ErV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a>\x91W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a>qV[P\x84\x82\x10\x15a>\xAEW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[\x81\x83R\x81\x81` \x85\x017P_` \x82\x84\x01\x01R_` `\x1F\x19`\x1F\x84\x01\x16\x84\x01\x01\x90P\x92\x91PPV[_\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\xFF\xE1\x836\x03\x01\x81\x12a?\x18W__\xFD[\x82\x01` \x81\x01\x905g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a?4W__\xFD[\x806\x03\x82\x13\x15a?BW__\xFD[` \x85Ra)J` \x86\x01\x82\x84a>\xBDV[`\x80\x81R_a?f`\x80\x83\x01\x87a>\xE6V[` \x83\x01\x95\x90\x95RP`@\x81\x01\x92\x90\x92R`\x01`\x01`\xA0\x1B\x03\x16``\x90\x91\x01R\x91\x90PV[\x84\x81R`\x80` \x82\x01R_a?\xA3`\x80\x83\x01\x86a>\xE6V[`\x01`\x01`\xA0\x1B\x03\x94\x90\x94\x16`@\x83\x01RP``\x01R\x92\x91PPV[__\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?\xF2W__\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a@\x0CW__\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a3\x0BW__\xFD[` \x81R_a\x1DZ` \x83\x01\x84\x86a>\xBDV[\x805\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\x14a7W__\xFD[aAJ6\x82\x86\x01a<\xD2V[\x82RP` \x83\x81\x015\x90\x82\x01R`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aApW__\xFD[aA|6\x82\x86\x01a<\xD2V[`@\x83\x01RP``\x83\x81\x015\x90\x82\x01R`\x80\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aA\xA5W__\xFD[aA\xB16\x82\x86\x01a<\xD2V[`\x80\x83\x01RP\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x068Wa\x068a;(V[\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\x83`\xF8\x1B\x16\x81R__\x83TaB\x05\x81a<1V[`\x01\x82\x16\x80\x15aB\x1CW`\x01\x81\x14aBUWaB\x8BV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x83\x16`\x01\x87\x01R`\x01\x82\x15\x15\x83\x02\x87\x01\x01\x93PaB\x8BV[\x86_R` _ _[\x83\x81\x10\x15aB\x80W\x81T`\x01\x82\x8A\x01\x01R`\x01\x82\x01\x91P` \x81\x01\x90PaB^V[PP`\x01\x82\x87\x01\x01\x93P[P\x91\x96\x95PPPPPPV[_` \x82\x84\x03\x12\x15aB\xA7W__\xFD[\x81Q\x80\x15\x15\x81\x14a\n\xD0W__\xFD[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[\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\x85\x16\x81R_aC\taC\x03`\x04\x84\x01\x87aB\xB6V[\x85aB\xB6V[\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\x93\x90\x93\x16\x83RPP`\x04\x01\x93\x92PPPV[_a\n\xD0\x82\x84aB\xB6V[_` \x82\x84\x03\x12\x15aCWW__\xFD[PQ\x91\x90PV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x068Wa\x068a;(V[_\x82aC\x8CWaC\x8Ca;lV[P\x06\x90V[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x068Wa\x068a;(V[`\x01\x81[`\x01\x84\x11\x15aC\xE5W\x80\x85\x04\x81\x11\x15aC\xC9WaC\xC9a;(V[`\x01\x84\x16\x15aC\xD7W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02aC\xAEV[\x93P\x93\x91PPV[_\x82aC\xFBWP`\x01a\x068V[\x81aD\x07WP_a\x068V[\x81`\x01\x81\x14aD\x1DW`\x02\x81\x14aD'WaDCV[`\x01\x91PPa\x068V[`\xFF\x84\x11\x15aD8WaD8a;(V[PP`\x01\x82\x1Ba\x068V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15aDfWP\x81\x81\na\x068V[aDr_\x19\x84\x84aC\xAAV[\x80_\x19\x04\x82\x11\x15aD\x85WaD\x85a;(V[\x02\x93\x92PPPV[_a\n\xD0\x83\x83aC\xEDV[`\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x068Wa\x068a;(V[` \x81R_a\n\xD0` \x83\x01\x84a5oV\xFE\xA2dipfsX\"\x12 A\xDF\x18\xE5x\xA0A\xC2\xE5-\x8F\x05\xEBc;\xA9l\0\x11;`\x87?x\xCB\xE1J\xFF\x1C\xB1\x7F\x07dsolcC\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\x01nW_5`\xE0\x1C\x80cj\x8C\xDE:\x11a\0\xD2W\x80c\xC5jE&\x11a\0\x88W\x80c\xDFi\xB1O\x11a\0cW\x80c\xDFi\xB1O\x14a\x03\xB2W\x80c\xEC\xCA,6\x14a\x03\xC5W\x80c\xFD?\xC2E\x14a\x042W__\xFD[\x80c\xC5jE&\x14a\x03|W\x80c\xCE\x1B\x81_\x14a\x03\x8FW\x80c\xD1\x92\x0F\xF0\x14a\x03\xA9W__\xFD[\x80c\xA3\x83\x01;\x11a\0\xB8W\x80c\xA3\x83\x01;\x14a\x02\xBAW\x80c\xB2#\xD9v\x14a\x02\xCDW\x80c\xBD*~>\x14a\x02\xE0W__\xFD[\x80cj\x8C\xDE:\x14a\x02\x8EW\x80c\x9C\xC6r.\x14a\x02\xA4W__\xFD[\x80cAEd\n\x11a\x01'W\x80cW+l\x05\x11a\x01\rW\x80cW+l\x05\x14a\x024W\x80c[\x8F\xE0B\x14a\x02eW\x80ch\x11\xA3\x11\x14a\x02xW__\xFD[\x80cAEd\n\x14a\x01\xFAW\x80cPj\x10\x9D\x14a\x02!W__\xFD[\x80c!\x0E\xC1\x81\x11a\x01WW\x80c!\x0E\xC1\x81\x14a\x01\xAEW\x80c6O\x1E\xC0\x14a\x01\xC1W\x80c:\xF3\xFC~\x14a\x01\xD6W__\xFD[\x80c\x11\xC17\xAA\x14a\x01rW\x80c\x1D\xFEu\x95\x14a\x01\x98W[__\xFD[a\x01\x85a\x01\x806`\x04a5OV[a\x04EV[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\x01\xA0a\x06>V[`@Qa\x01\x8F\x92\x91\x90a5\xEBV[a\x01\x85a\x01\xBC6`\x04a6\xD9V[a\x08\xA0V[a\x01\xD4a\x01\xCF6`\x04a7AV[a\n\xD7V[\0[a\x01\xE9a\x01\xE46`\x04a7\x9CV[a\x0C,V[`@Qa\x01\x8F\x95\x94\x93\x92\x91\x90a7\xB3V[a\x02\ra\x02\x086`\x04a7\x9CV[a\x0C\xFEV[`@Qa\x01\x8F\x98\x97\x96\x95\x94\x93\x92\x91\x90a7\xFBV[a\x01\xD4a\x02/6`\x04a7\x9CV[a\r\xEFV[a\x02Ua\x02B6`\x04a8PV[_T`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x91\x16\x14\x90V[`@Q\x90\x15\x15\x81R` \x01a\x01\x8FV[a\x01\xD4a\x02s6`\x04a8iV[a\x0E\xD4V[a\x02\x80a\x0F\xF0V[`@Qa\x01\x8F\x92\x91\x90a8\x9CV[a\x02\x96a\x11\xB4V[`@Qa\x01\x8F\x92\x91\x90a9+V[a\x02\xACa\x13\xBAV[`@Qa\x01\x8F\x92\x91\x90a9\xC3V[a\x01\xD4a\x02\xC86`\x04a7\x9CV[a\x16\x1DV[a\x01\xD4a\x02\xDB6`\x04a:\xB1V[a\x16\xC1V[a\x039a\x02\xEE6`\x04a7\x9CV[`\x02` \x81\x90R_\x91\x82R`@\x90\x91 \x80T`\x01\x82\x01T\x92\x82\x01T`\x03\x83\x01T`\x04\x84\x01T`\x05\x85\x01T`\x06\x90\x95\x01T\x93\x95\x94`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x94\x92\x93\x91\x82\x16\x92\x91\x16\x90\x87V[`@\x80Q\x97\x88R` \x88\x01\x96\x90\x96R`\x01`\x01`\xA0\x1B\x03\x94\x85\x16\x95\x87\x01\x95\x90\x95R``\x86\x01\x92\x90\x92R\x82\x16`\x80\x85\x01R\x16`\xA0\x83\x01R`\xC0\x82\x01R`\xE0\x01a\x01\x8FV[a\x01\xD4a\x03\x8A6`\x04a7\x9CV[a\x18]V[_T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01\x8FV[a\x01\x85aT`\x81V[a\x01\xD4a\x03\xC06`\x04a7\x9CV[a\x19@V[a\x04\x07a\x03\xD36`\x04a7\x9CV[`\x03` \x81\x90R_\x91\x82R`@\x90\x91 \x80T`\x01\x82\x01T`\x02\x83\x01T\x92\x90\x93\x01T\x90\x92`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x92\x91\x16\x84V[`@\x80Q\x94\x85R`\x01`\x01`\xA0\x1B\x03\x93\x84\x16` \x86\x01R\x84\x01\x91\x90\x91R\x16``\x82\x01R`\x80\x01a\x01\x8FV[a\x01\xD4a\x04@6`\x04a:\xB1V[a\x1ASV[_\x82\x81R`\x01` R`@\x81 \x80T\x83\x11\x15a\x04_W__\xFD[_\x83\x11a\x04jW__\xFD[\x80T`\x03\x82\x01T_\x91\x90a\x04~\x90\x86a;UV[a\x04\x88\x91\x90a;\x99V[\x90P_\x81\x11a\x04\x99Wa\x04\x99a;\xACV[\x80\x82`\x03\x01T\x10\x15a\x04\xADWa\x04\xADa;\xACV[\x80\x82`\x03\x01_\x82\x82Ta\x04\xC0\x91\x90a;\xD9V[\x90\x91UPP\x81T\x84\x90\x83\x90_\x90a\x04\xD8\x90\x84\x90a;\xD9V[\x90\x91UPP`@\x80Q`\xE0\x81\x01\x82R\x86\x81R` \x81\x01\x86\x90R`\x02\x84\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x92\x82\x01\x92\x90\x92R``\x81\x01\x83\x90R`\x04\x84\x01T\x90\x91\x16`\x80\x82\x01R_\x90`\xA0\x81\x01a\x05*a\x1B\xE0V[`\x01`\x01`\xA0\x1B\x03\x16\x81RB` \x90\x91\x01R`\x05\x80T\x91\x92P_\x91\x90\x82a\x05P\x83a;\xECV[\x90\x91UP_\x81\x81R`\x02` \x81\x81R`@\x92\x83\x90 \x86Q\x81U\x86\x82\x01Q`\x01\x82\x01U\x86\x84\x01Q\x81\x84\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x17\x90\x91U``\x80\x8A\x01Q`\x03\x85\x01U`\x80\x8A\x01Q`\x04\x85\x01\x80T\x84\x16\x91\x85\x16\x91\x90\x91\x17\x90U`\xA0\x8A\x01Q`\x05\x85\x01\x80T\x90\x93\x16\x90\x84\x16\x17\x90\x91U`\xC0\x89\x01Q`\x06\x90\x93\x01\x92\x90\x92U\x92\x89\x01T\x84Q\x8C\x81R\x92\x83\x01\x89\x90R\x90\x92\x16\x92\x81\x01\x92\x90\x92R\x91\x92P\x82\x91\x89\x91\x7F\xC3\x9A\x1A]\xDC\x0E\x85\xC9U\xFE.\x1A\xBE\xB4<\x94\xCE\x182.u\xBB=D\xE8\x0Fu\x9F\xF9\xD04\xB9\x91\x01`@Q\x80\x91\x03\x90\xA3\x93PPPP[\x92\x91PPV[``\x80_\x80[`\x05T\x81\x10\x15a\x06\x83W_\x81\x81R`\x01` R`@\x90 `\x04\x01T`\x01`\x01`\xA0\x1B\x03\x16\x15a\x06{W\x81a\x06w\x81a;\xECV[\x92PP[`\x01\x01a\x06DV[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\x9EWa\x06\x9Ea<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x06\xD7W\x81` \x01[a\x06\xC4a4eV[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x06\xBCW\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\xF4Wa\x06\xF4a<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x07\x1DW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x05T\x81\x10\x15a\x08\x94W_\x81\x81R`\x01` R`@\x90 `\x04\x01T`\x01`\x01`\xA0\x1B\x03\x16\x15a\x08\x8CW`\x01_\x82\x81R` \x01\x90\x81R` \x01_ `@Q\x80`\xA0\x01`@R\x90\x81_\x82\x01T\x81R` \x01`\x01\x82\x01`@Q\x80` \x01`@R\x90\x81_\x82\x01\x80Ta\x07\x90\x90a<1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07\xBC\x90a<1V[\x80\x15a\x08\x07W\x80`\x1F\x10a\x07\xDEWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x08\x07V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\xEAW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP\x81R`\x02\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16` \x83\x01R`\x03\x83\x01T`@\x83\x01R`\x04\x90\x92\x01T\x90\x91\x16``\x90\x91\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x08UWa\x08Ua<|V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x08sWa\x08sa<|V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x08\x88\x81a;\xECV[\x92PP[`\x01\x01a\x07#V[P\x91\x95\x90\x94P\x92PPPV[_\x83\x81R`\x03` R`@\x81 \x82a\x08\xB6W__\xFD[\x80T\x83\x11\x15a\x08\xC3W__\xFD[\x80T`\x02\x82\x01T_\x91\x90a\x08\xD7\x90\x86a;UV[a\x08\xE1\x91\x90a;\x99V[\x90P_\x81\x11a\x08\xF2Wa\x08\xF2a;\xACV[\x80\x82`\x02\x01T\x10\x15a\t\x06Wa\t\x06a;\xACV[\x80\x82`\x02\x01_\x82\x82Ta\t\x19\x91\x90a;\xD9V[\x90\x91UPP\x81T\x84\x90\x83\x90_\x90a\t1\x90\x84\x90a;\xD9V[\x90\x91UPa\tX\x90Pa\tBa\x1B\xE0V[`\x01\x84\x01T`\x01`\x01`\xA0\x1B\x03\x16\x900\x84a\x1C0V[`\x05\x80T_\x91\x82a\th\x83a;\xECV[\x91\x90PU\x90P`@Q\x80a\x01\0\x01`@R\x80\x88\x81R` \x01\x87a\t\x8A\x90a=]V[\x81R` \x81\x01\x87\x90R`\x01\x85\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`@\x83\x01R``\x82\x01\x85\x90R`\x03\x86\x01T\x16`\x80\x82\x01R`\xA0\x01a\t\xC5a\x1B\xE0V[`\x01`\x01`\xA0\x1B\x03\x16\x81RB` \x91\x82\x01R_\x83\x81R`\x04\x82R`@\x90 \x82Q\x81U\x90\x82\x01Q\x80Q`\x01\x83\x01\x90\x81\x90a\t\xFE\x90\x82a>\x02V[PPP`@\x82\x81\x01Q`\x02\x83\x01U``\x83\x01Q`\x03\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x17\x90\x91U`\x80\x85\x01Q`\x04\x85\x01U`\xA0\x85\x01Q`\x05\x85\x01\x80T\x83\x16\x91\x84\x16\x91\x90\x91\x17\x90U`\xC0\x85\x01Q`\x06\x85\x01\x80T\x90\x92\x16\x90\x83\x16\x17\x90U`\xE0\x90\x93\x01Q`\x07\x90\x92\x01\x91\x90\x91U`\x01\x85\x01T\x90Q\x83\x92\x8A\x92\x7Fe>\r\x81\xF2\xC9\x9B\xEB\xA3Y\xDF\xB1{I\x9A\\\xFF+\xE9\xD9PQHR\"M\xF8\xC0\x97\xC2\x19!\x92a\n\xC3\x92\x8C\x92\x8C\x92\x8A\x92\x91\x90\x91\x16\x90a?TV[`@Q\x80\x91\x03\x90\xA3\x92PPP[\x93\x92PPPV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\n\xE9W__\xFD[a\x0B\x06a\n\xF4a\x1B\xE0V[`\x01`\x01`\xA0\x1B\x03\x84\x16\x900\x84a\x1C0V[`\x05\x80T_\x91\x82a\x0B\x16\x83a;\xECV[\x91\x90PU\x90P`@Q\x80`\xA0\x01`@R\x80\x86\x81R` \x01\x85a\x0B7\x90a=]V[\x81R` \x01\x84`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x83\x81R` \x01a\x0BYa\x1B\xE0V[`\x01`\x01`\xA0\x1B\x03\x16\x90R_\x82\x81R`\x01` \x81\x81R`@\x90\x92 \x83Q\x81U\x91\x83\x01Q\x80Q\x90\x91\x83\x01\x90\x81\x90a\x0B\x8F\x90\x82a>\x02V[PPP`@\x82\x81\x01Q`\x02\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x17\x90\x91U``\x85\x01Q`\x03\x85\x01U`\x80\x90\x94\x01Q`\x04\x90\x93\x01\x80T\x90\x94\x16\x92\x16\x91\x90\x91\x17\x90\x91UQ\x7F\x98\xC7\xC6\x80@=G@=\xEAJW\r\x0ElW\x16S\x8CIB\x0E\xF4q\xCE\xC4(\xF5\xA5\x85,\x06\x90a\x0C\x1D\x90\x87\x90\x87\x90\x87\x90\x87\x90a?\x8BV[`@Q\x80\x91\x03\x90\xA1PPPPPV[`\x01` \x81\x81R_\x92\x83R`@\x92\x83\x90 \x80T\x84Q\x92\x83\x01\x90\x94R\x91\x82\x01\x80T\x82\x90\x82\x90a\x0CY\x90a<1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C\x85\x90a<1V[\x80\x15a\x0C\xD0W\x80`\x1F\x10a\x0C\xA7Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C\xD0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0C\xB3W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP`\x02\x82\x01T`\x03\x83\x01T`\x04\x90\x93\x01T\x91\x92`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x92\x90\x91\x16\x85V[`\x04` R\x80_R`@_ _\x91P\x90P\x80_\x01T\x90\x80`\x01\x01`@Q\x80` \x01`@R\x90\x81_\x82\x01\x80Ta\r2\x90a<1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r^\x90a<1V[\x80\x15a\r\xA9W\x80`\x1F\x10a\r\x80Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\r\xA9V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r\x8CW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP`\x02\x82\x01T`\x03\x83\x01T`\x04\x84\x01T`\x05\x85\x01T`\x06\x86\x01T`\x07\x90\x96\x01T\x94\x95\x93\x94`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x94\x92\x93\x91\x82\x16\x92\x90\x91\x16\x90\x88V[_\x81\x81R`\x01` R`@\x90 a\x0E\x04a\x1B\xE0V[`\x04\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x0E\x1FW__\xFD[a\x0EDa\x0E*a\x1B\xE0V[`\x03\x83\x01T`\x02\x84\x01T`\x01`\x01`\xA0\x1B\x03\x16\x91\x90a\x1C\xE7V[_\x82\x81R`\x01` \x81\x90R`@\x82 \x82\x81U\x91\x90\x82\x01\x81a\x0Ee\x82\x82a4\xA6V[PPP`\x02\x81\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U_`\x03\x83\x01U`\x04\x90\x91\x01\x80T\x90\x91\x16\x90U`@Q\x82\x81R\x7F\xC3@\xE7\xACH\xDC\x80\xEEy?\xC6&i`\xBD_\x1B\xD2\x1B\xE9\x1C\x8A\x95\xE2\x18\x17\x81\x13\xF7\x9E\x17\xB4\x90` \x01[`@Q\x80\x91\x03\x90\xA1PPV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x0E\xE6W__\xFD[_\x83\x11a\x0E\xF1W__\xFD[_\x81\x11a\x0E\xFCW__\xFD[`\x05\x80T_\x91\x82a\x0F\x0C\x83a;\xECV[\x91\x90PU\x90P`@Q\x80`\x80\x01`@R\x80\x85\x81R` \x01\x84`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x83\x81R` \x01a\x0F@a\x1B\xE0V[`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x90\x91R_\x83\x81R`\x03` \x81\x81R`@\x92\x83\x90 \x85Q\x81U\x85\x82\x01Q`\x01\x82\x01\x80T\x91\x87\x16s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x92\x83\x16\x17\x90U\x86\x85\x01Q`\x02\x83\x01U``\x96\x87\x01Q\x91\x90\x93\x01\x80T\x91\x86\x16\x91\x90\x93\x16\x17\x90\x91U\x81Q\x88\x81R\x92\x87\x16\x90\x83\x01R\x81\x01\x84\x90R\x82\x91\x7F\xFF\x1C\xE2\x10\xDE\xFC\xD3\xBA\x1A\xDFv\xC9A\x9A\x07X\xFA`\xFD>\xB3\x8C{\xD9A\x8F`\xB5u\xB7n$\x91\x01`@Q\x80\x91\x03\x90\xA2PPPPV[``\x80_\x80[`\x05T\x81\x10\x15a\x106W_\x81\x81R`\x03` \x81\x90R`@\x90\x91 \x01T`\x01`\x01`\xA0\x1B\x03\x16\x15a\x10.W\x81a\x10*\x81a;\xECV[\x92PP[`\x01\x01a\x0F\xF6V[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10QWa\x10Qa<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x10\xA1W\x81` \x01[`@\x80Q`\x80\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x92\x82\x01\x81\x90R``\x82\x01R\x82R_\x19\x90\x92\x01\x91\x01\x81a\x10oW\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x10\xBEWa\x10\xBEa<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x10\xE7W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x05T\x81\x10\x15a\x08\x94W_\x81\x81R`\x03` \x81\x90R`@\x90\x91 \x01T`\x01`\x01`\xA0\x1B\x03\x16\x15a\x11\xACW_\x81\x81R`\x03` \x81\x81R`@\x92\x83\x90 \x83Q`\x80\x81\x01\x85R\x81T\x81R`\x01\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x93\x82\x01\x93\x90\x93R`\x02\x82\x01T\x94\x81\x01\x94\x90\x94R\x90\x91\x01T\x16``\x82\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x11uWa\x11ua<|V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x11\x93Wa\x11\x93a<|V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x11\xA8\x81a;\xECV[\x92PP[`\x01\x01a\x10\xEDV[``\x80_\x80[`\x05T\x81\x10\x15a\x11\xF0W_\x81\x81R`\x02` R`@\x90 `\x01\x01T\x15a\x11\xE8W\x81a\x11\xE4\x81a;\xECV[\x92PP[`\x01\x01a\x11\xBAV[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\x0BWa\x12\x0Ba<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x12\x90W\x81` \x01[a\x12}`@Q\x80`\xE0\x01`@R\x80_\x81R` \x01_\x81R` \x01_`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01_\x81R` \x01_`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01_`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01_\x81RP\x90V[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x12)W\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x12\xADWa\x12\xADa<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x12\xD6W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x05T\x81\x10\x15a\x08\x94W_\x81\x81R`\x02` R`@\x90 `\x01\x01T\x15a\x13\xB2W_\x81\x81R`\x02` \x81\x81R`@\x92\x83\x90 \x83Q`\xE0\x81\x01\x85R\x81T\x81R`\x01\x82\x01T\x92\x81\x01\x92\x90\x92R\x91\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x93\x82\x01\x93\x90\x93R`\x03\x82\x01T``\x82\x01R`\x04\x82\x01T\x83\x16`\x80\x82\x01R`\x05\x82\x01T\x90\x92\x16`\xA0\x83\x01R`\x06\x01T`\xC0\x82\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x13{Wa\x13{a<|V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x13\x99Wa\x13\x99a<|V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x13\xAE\x81a;\xECV[\x92PP[`\x01\x01a\x12\xDCV[``\x80_\x80[`\x05T\x81\x10\x15a\x13\xF6W_\x81\x81R`\x04` R`@\x90 `\x02\x01T\x15a\x13\xEEW\x81a\x13\xEA\x81a;\xECV[\x92PP[`\x01\x01a\x13\xC0V[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x14\x11Wa\x14\x11a<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x14JW\x81` \x01[a\x147a4\xE0V[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x14/W\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x14gWa\x14ga<\x04V[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x14\x90W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x05T\x81\x10\x15a\x08\x94W_\x81\x81R`\x04` R`@\x90 `\x02\x01T\x15a\x16\x15W`\x04_\x82\x81R` \x01\x90\x81R` \x01_ `@Q\x80a\x01\0\x01`@R\x90\x81_\x82\x01T\x81R` \x01`\x01\x82\x01`@Q\x80` \x01`@R\x90\x81_\x82\x01\x80Ta\x14\xFB\x90a<1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x15'\x90a<1V[\x80\x15a\x15rW\x80`\x1F\x10a\x15IWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x15rV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15UW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP\x81R`\x02\x82\x01T` \x82\x01R`\x03\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`@\x83\x01R`\x04\x83\x01T``\x83\x01R`\x05\x83\x01T\x81\x16`\x80\x83\x01R`\x06\x83\x01T\x16`\xA0\x82\x01R`\x07\x90\x91\x01T`\xC0\x90\x91\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x15\xDEWa\x15\xDEa<|V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x15\xFCWa\x15\xFCa<|V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x16\x11\x81a;\xECV[\x92PP[`\x01\x01a\x14\x96V[_\x81\x81R`\x03` R`@\x90 a\x162a\x1B\xE0V[`\x03\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x16MW__\xFD[_\x82\x81R`\x03` \x81\x81R`@\x80\x84 \x84\x81U`\x01\x81\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U`\x02\x82\x01\x95\x90\x95U\x90\x92\x01\x80T\x90\x93\x16\x90\x92UQ\x83\x81R\x7F<\xD4u\xB0\x92\xE8\xB3y\xF6\xBA\r\x9E\x0E\x0C\x8F0p^s2\x1D\xC5\xC9\xF8\x0C\xE4\xAD8\xDB{\xE1\xAA\x91\x01a\x0E\xC8V[_\x83\x81R`\x02` R`@\x90 a\x16\xD6a\x1B\xE0V[`\x05\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x16\xF1W__\xFD[`\x06T`\x01`\x01`\xA0\x1B\x03\x16c\xD3\x8C)\xA1a\x17\x0F`@\x85\x01\x85a?\xBFV[`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x17,\x92\x91\x90a@ V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x17CW__\xFD[PZ\xF1\x15\x80\x15a\x17UW=__>=_\xFD[PPPPa\x17\x86`\x07T\x84a\x17i\x90a@bV[a\x17r\x85aA\x10V[`\x06T`\x01`\x01`\xA0\x1B\x03\x16\x92\x91\x90a\x1D5V[P\x80T_\x90\x81R`\x01` \x81\x90R`@\x90\x91 \x80T\x90\x91a\x17\xAA\x91\x90\x83\x01\x86a\x1DbV[`\x05\x82\x01T`\x03\x83\x01T`\x02\x84\x01Ta\x17\xD1\x92`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x92\x91\x16\x90a\x1C\xE7V[_\x85\x81R`\x02` \x81\x81R`@\x80\x84 \x84\x81U`\x01\x81\x01\x85\x90U\x92\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U`\x03\x84\x01\x85\x90U`\x04\x84\x01\x80T\x82\x16\x90U`\x05\x84\x01\x80T\x90\x91\x16\x90U`\x06\x90\x92\x01\x92\x90\x92UQ\x86\x81R\x7F\xB4\xC9\x8D\xE2\x10ik<\xF2\x1E\x993\\\x1E\xE3\xA0\xAE4\xA2g\x13A*J\xDD\xE8\xAFYav\xF3~\x91\x01a\x0C\x1DV[_\x81\x81R`\x02` R`@\x90 a\x18ra\x1B\xE0V[`\x04\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x18\x8DW__\xFD[aT`\x81`\x06\x01Ta\x18\x9F\x91\x90aA\xBDV[B\x11a\x18\xA9W__\xFD[a\x18\xB4a\x0E*a\x1B\xE0V[_\x82\x81R`\x02` \x81\x81R`@\x80\x84 \x84\x81U`\x01\x81\x01\x85\x90U\x92\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U`\x03\x84\x01\x85\x90U`\x04\x84\x01\x80T\x82\x16\x90U`\x05\x84\x01\x80T\x90\x91\x16\x90U`\x06\x90\x92\x01\x92\x90\x92UQ\x83\x81R\x7F>^\xA3X\xE9\xEBL\xDFD\xCD\xC7y8\xAD\xE8\x07K\x12@\xA6\xD8\xC0\xFD\x13r\x86q\xB8.\x80\n\xD6\x91\x01a\x0E\xC8V[_\x81\x81R`\x04` R`@\x90 `\x07\x81\x01Ta\x19_\x90aT`\x90aA\xBDV[B\x11a\x19iW__\xFD[a\x19qa\x1B\xE0V[`\x06\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x19\x8CW__\xFD[a\x19\xB1a\x19\x97a\x1B\xE0V[`\x04\x83\x01T`\x03\x84\x01T`\x01`\x01`\xA0\x1B\x03\x16\x91\x90a\x1C\xE7V[_\x82\x81R`\x04` R`@\x81 \x81\x81U\x90`\x01\x82\x01\x81a\x19\xD1\x82\x82a4\xA6V[PP_`\x02\x83\x01\x81\x90U`\x03\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U`\x04\x84\x01\x82\x90U`\x05\x84\x01\x80T\x82\x16\x90U`\x06\x84\x01\x80T\x90\x91\x16\x90U`\x07\x90\x92\x01\x91\x90\x91UP`@Q\x82\x81R\x7Fx\xF5\x1Fb\xF7\xCF\x13\x81\xC6s\xC2~\xAE\x18}\xD6\xC5\x88\xDCf$\xCEYi}\xBB>\x1D|\x1B\xBC\xDF\x90` \x01a\x0E\xC8V[_\x83\x81R`\x04` R`@\x90 a\x1Aha\x1B\xE0V[`\x05\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x91\x16\x14a\x1A\x83W__\xFD[`\x06T`\x01`\x01`\xA0\x1B\x03\x16c\xD3\x8C)\xA1a\x1A\xA1`@\x85\x01\x85a?\xBFV[`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1A\xBE\x92\x91\x90a@ V[_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1A\xD5W__\xFD[PZ\xF1\x15\x80\x15a\x1A\xE7W=__>=_\xFD[PPPPa\x1A\xFB`\x07T\x84a\x17i\x90a@bV[Pa\x1B\x0E\x81`\x02\x01T\x82`\x01\x01\x85a\x1DbV[`\x05\x81\x01T`\x04\x82\x01T`\x03\x83\x01Ta\x1B5\x92`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x92\x91\x16\x90a\x1C\xE7V[_\x84\x81R`\x04` R`@\x81 \x81\x81U\x90`\x01\x82\x01\x81a\x1BU\x82\x82a4\xA6V[PP_`\x02\x83\x01\x81\x90U`\x03\x83\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x90\x81\x16\x90\x91U`\x04\x84\x01\x82\x90U`\x05\x84\x01\x80T\x82\x16\x90U`\x06\x84\x01\x80T\x90\x91\x16\x90U`\x07\x90\x92\x01\x91\x90\x91UP`@Q\x84\x81R\x7F\xCFV\x10a\xDBx\xF7\xBCQ\x8D7\xFE\x86q\x85\x14\xC6@\xCC\xC5\xC3\xF1)8(\xB9U\xE6\x8F\x19\xF5\xFB\x90` \x01`@Q\x80\x91\x03\x90\xA1PPPPV[_`\x146\x10\x80\x15\x90a\x1B\xFBWP_T`\x01`\x01`\xA0\x1B\x03\x163\x14[\x15a\x1C+WP\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xEC6\x015``\x1C\x90V[P3\x90V[`@Q`\x01`\x01`\xA0\x1B\x03\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x1C\xE1\x90\x85\x90\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\x90`\x84\x01[`@\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\x1EyV[PPPPV[`@Q`\x01`\x01`\xA0\x1B\x03\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x1D0\x90\x84\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\x90`d\x01a\x1C}V[PPPV[_a\x1D?\x83a\x1F]V[\x90Pa\x1DK\x81\x83a MV[a\x1DZ\x85\x85\x84`@\x01Qa\"\xB1V[\x94\x93PPPPV[_\x82_\x01\x80Ta\x1Dq\x90a<1V[`@Qa\x1D\x83\x92P\x85\x90` \x01aA\xD0V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P_a\x1D\xEA\x83\x80`@\x01\x90a\x1D\xAF\x91\x90a?\xBFV[\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\x91RP\x86\x92Pa&\x01\x91PPV[Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P\x84\x81\x10\x15a\x1ErW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`;`$\x82\x01R\x7FBitcoin transaction amount is lo`D\x82\x01R\x7Fwer than in accepted order.\0\0\0\0\0`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[PPPPPV[_a\x1E\xCD\x82`@Q\x80`@\x01`@R\x80` \x81R` \x01\x7FSafeERC20: low-level call failed\x81RP\x85`\x01`\x01`\xA0\x1B\x03\x16a'\x9F\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x1D0W\x80\x80` \x01\x90Q\x81\x01\x90a\x1E\xEB\x91\x90aB\x97V[a\x1D0W`@QbF\x1B\xCD`\xE5\x1B\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\x1EiV[_a\x1Fk\x82` \x01Qa'\xADV[a\x1F\xB7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FInvalid input vector provided\0\0\0`D\x82\x01R`d\x01a\x1EiV[a\x1F\xC4\x82`@\x01Qa(GV[a \x10W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FInvalid output vector provided\0\0`D\x82\x01R`d\x01a\x1EiV[a\x068\x82_\x01Q\x83` \x01Q\x84`@\x01Q\x85``\x01Q`@Q` \x01a 9\x94\x93\x92\x91\x90aB\xCDV[`@Q` \x81\x83\x03\x03\x81R\x90`@Ra(\xD4V[\x80Qa X\x90a(\xF6V[a \xA4W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7FBad merkle array proof\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x1EiV[`\x80\x81\x01QQ\x81QQ\x14a! W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`/`$\x82\x01R\x7FTx not on same level of merkle t`D\x82\x01R\x7Free as coinbase\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x1EiV[_a!.\x82`@\x01Qa)\x0CV[\x82Q` \x84\x01Q\x91\x92Pa!E\x91\x85\x91\x84\x91a)\x18V[a!\xB7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`<`$\x82\x01R\x7FTx merkle proof is not valid for`D\x82\x01R\x7F provided header and tx hash\0\0\0\0`d\x82\x01R`\x84\x01a\x1EiV[_`\x02\x83``\x01Q`@Q` \x01a!\xD1\x91\x81R` \x01\x90V[`@\x80Q`\x1F\x19\x81\x84\x03\x01\x81R\x90\x82\x90Ra!\xEB\x91aC=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\")\x91\x90aCGV[`\x80\x84\x01Q\x90\x91Pa\"?\x90\x82\x90\x84\x90_a)\x18V[a\x1C\xE1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`?`$\x82\x01R\x7FCoinbase merkle proof is not val`D\x82\x01R\x7Fid for provided header and hash\0`d\x82\x01R`\x84\x01a\x1EiV[_\x83`\x01`\x01`\xA0\x1B\x03\x16c\x117d\xBE`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\"\xEEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a#\x12\x91\x90aCGV[\x90P_\x84`\x01`\x01`\xA0\x1B\x03\x16c+\x97\xBE$`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a#QW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a#u\x91\x90aCGV[\x90P_\x80a#\x8Aa#\x85\x86a)SV[a)^V[\x90P\x83\x81\x03a#\x9BW\x83\x91Pa$\x18V[\x82\x81\x03a#\xAAW\x82\x91Pa$\x18V[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`%`$\x82\x01R\x7FNot at current or previous diffi`D\x82\x01R\x7Fculty\0\0\0\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\x1EiV[_a$\"\x86a)\x85V[\x90P_\x19\x81\x03a$\x9AW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`#`$\x82\x01R\x7FInvalid length of the headers ch`D\x82\x01R\x7Fain\0\0\0\0\0\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\x1EiV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81\x03a%\tW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FInvalid headers chain\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x1EiV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFD\x81\x03a%xW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FInsufficient work in a header\0\0\0`D\x82\x01R`d\x01a\x1EiV[a%\x82\x87\x84a;UV[\x81\x10\x15a%\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FInsufficient accumulated difficu`D\x82\x01R\x7Flty in header chain\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x1EiV[PPPPPPPPV[`@\x80Q``\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x82\x84\x01\x82\x90R\x83Q\x80\x85\x01\x90\x94R\x81\x84R\x83\x01R\x90a&5\x84a+\xA9V[` \x83\x01R\x80\x82R\x81a&G\x82a;\xECV[\x90RP_\x80[\x82` \x01Q\x81\x10\x15a'IW\x82Q_\x90a&h\x90\x88\x90a+\xBEV[\x84Q\x90\x91P_\x90a&z\x90\x89\x90a,\x1EV[\x90P_a&\x88`\x08\x84a;\xD9V[\x86Q\x90\x91P_\x90a&\x9A\x90`\x08aA\xBDV[\x8A\x81\x01` \x01\x83\x90 \x90\x91P\x80\x8A\x03a&\xD4W`\x01\x96P\x83\x89_\x01\x81\x81Qa&\xC2\x91\x90aC^V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RPa'$V[_a&\xE2\x8C\x8A_\x01Qa,\x94V[\x90P`\x01`\x01`\xA0\x1B\x03\x81\x16\x15a'\x03W`\x01`\x01`\xA0\x1B\x03\x81\x16` \x8B\x01R[_a'\x11\x8D\x8B_\x01Qa-tV[\x90P\x80\x15a'!W`@\x8B\x01\x81\x90R[PP[\x84\x88_\x01\x81\x81Qa'5\x91\x90aA\xBDV[\x90RPP`\x01\x90\x94\x01\x93Pa&M\x92PPPV[P\x80a'\x97W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FNo output found for scriptPubKey`D\x82\x01R`d\x01a\x1EiV[PP\x92\x91PPV[``a\x1DZ\x84\x84_\x85a.TV[___a'\xB9\x84a+\xA9V[\x90\x92P\x90P\x80\x15\x80a'\xCBWP_\x19\x82\x14[\x15a'\xD9WP_\x93\x92PPPV[_a'\xE5\x83`\x01aA\xBDV[\x90P_[\x82\x81\x10\x15a(:W\x85Q\x82\x10a(\x04WP_\x95\x94PPPPPV[_a(\x0F\x87\x84a/\x98V[\x90P_\x19\x81\x03a(%WP_\x96\x95PPPPPPV[a(/\x81\x84aA\xBDV[\x92PP`\x01\x01a'\xE9V[P\x93Q\x90\x93\x14\x93\x92PPPV[___a(S\x84a+\xA9V[\x90\x92P\x90P\x80\x15\x80a(eWP_\x19\x82\x14[\x15a(sWP_\x93\x92PPPV[_a(\x7F\x83`\x01aA\xBDV[\x90P_[\x82\x81\x10\x15a(:W\x85Q\x82\x10a(\x9EWP_\x95\x94PPPPPV[_a(\xA9\x87\x84a+\xBEV[\x90P_\x19\x81\x03a(\xBFWP_\x96\x95PPPPPPV[a(\xC9\x81\x84aA\xBDV[\x92PP`\x01\x01a(\x83V[_` _\x83Q` \x85\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x91\x90PV[_` \x82Qa)\x05\x91\x90aC~V[\x15\x92\x91PPV[`D\x81\x01Q_\x90a\x068V[_\x83\x85\x14\x80\x15a)&WP\x81\x15[\x80\x15a)1WP\x82Q\x15[\x15a)>WP`\x01a\x1DZV[a)J\x85\x84\x86\x85a/\xDEV[\x95\x94PPPPPV[_a\x068\x82_a0\x83V[_a\x068{\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\x83a1\x1CV[_`P\x82Qa)\x94\x91\x90aC~V[\x15a)\xA1WP_\x19\x91\x90PV[P_\x80\x80[\x83Q\x81\x10\x15a+\xA2W\x80\x15a)\xEDWa)\xC0\x84\x82\x84a1'V[a)\xEDWP\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x93\x92PPPV[_a)\xF8\x85\x83a0\x83V[\x90Pa*\x06\x85\x83`Pa1PV[\x92P\x80a+I\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x11\x15a+yWP\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFD\x94\x93PPPPV[a+\x82\x81a)^V[a+\x8C\x90\x85aA\xBDV[\x93Pa+\x9B\x90P`P\x82aA\xBDV[\x90Pa)\xA6V[PP\x91\x90PV[__a+\xB5\x83_a1uV[\x91P\x91P\x91P\x91V[_a+\xCA\x82`\taA\xBDV[\x83Q\x10\x15a+\xDAWP_\x19a\x068V[_\x80a+\xF0\x85a+\xEB\x86`\x08aA\xBDV[a1uV[\x90\x92P\x90P`\x01\x82\x01a,\x08W_\x19\x92PPPa\x068V[\x80a,\x14\x83`\taA\xBDV[a)J\x91\x90aA\xBDV[_\x80a,*\x84\x84a3\x12V[`\xC0\x1C\x90P_a)J\x82d\xFF\0\0\0\xFF`\x08\x82\x81\x1C\x91\x82\x16e\xFF\0\0\0\xFF\0\x93\x90\x91\x1B\x92\x83\x16\x17`\x10\x90\x81\x1Bg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16f\xFF\0\xFF\0\xFF\0\xFF\x92\x90\x92\x16g\xFF\0\xFF\0\xFF\0\xFF\0\x90\x93\x16\x92\x90\x92\x17\x90\x91\x1Ce\xFF\xFF\0\0\xFF\xFF\x16\x17` \x81\x81\x1C\x91\x90\x1B\x17\x90V[_\x82a,\xA1\x83`\taA\xBDV[\x81Q\x81\x10a,\xB1Wa,\xB1a<|V[` \x91\x01\x01Q\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\x16\x7Fj\0\0\0\0\0\0\0\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-\x06WP_a\x068V[_\x83a-\x13\x84`\naA\xBDV[\x81Q\x81\x10a-#Wa-#a<|V[\x01` \x01Q\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\x81\x16\x91P`\xF8\x1C`\x14\x03a-mW_a-c\x84`\x0BaA\xBDV[\x85\x01`\x14\x01Q\x92PP[P\x92\x91PPV[_\x82a-\x81\x83`\taA\xBDV[\x81Q\x81\x10a-\x91Wa-\x91a<|V[` \x91\x01\x01Q\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\x16\x7Fj\0\0\0\0\0\0\0\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-\xE6WP_a\x068V[_\x83a-\xF3\x84`\naA\xBDV[\x81Q\x81\x10a.\x03Wa.\x03a<|V[\x01` \x90\x81\x01Q\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\x81\x16\x92P`\xF8\x1C\x90\x03a-mW_a.D\x84`\x0BaA\xBDV[\x85\x01` \x01Q\x92PPP\x92\x91PPV[``\x82G\x10\x15a.\xCCW`@QbF\x1B\xCD`\xE5\x1B\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\x1EiV[`\x01`\x01`\xA0\x1B\x03\x85\x16;a/#W`@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\x1EiV[__\x86`\x01`\x01`\xA0\x1B\x03\x16\x85\x87`@Qa/>\x91\x90aCa/}V[``\x91P[P\x91P\x91Pa/\x8D\x82\x82\x86a3 V[\x97\x96PPPPPPPV[___a/\xA5\x85\x85a3YV[\x90\x92P\x90P`\x01\x82\x01a/\xBDW_\x19\x92PPPa\x068V[\x80a/\xC9\x83`%aA\xBDV[a/\xD3\x91\x90aA\xBDV[a)J\x90`\x04aA\xBDV[_` \x84Qa/\xED\x91\x90aC~V[\x15a/\xF9WP_a\x1DZV[\x83Q_\x03a0\x08WP_a\x1DZV[\x81\x85_[\x86Q\x81\x10\x15a0vWa0 `\x02\x84aC~V[`\x01\x03a0DWa0=a07\x88\x83\x01` \x01Q\x90V[\x83a3\x97V[\x91Pa0]V[a0Z\x82a0U\x89\x84\x01` \x01Q\x90V[a3\x97V[\x91P[`\x01\x92\x90\x92\x1C\x91a0o` \x82aA\xBDV[\x90Pa0\x0CV[P\x90\x93\x14\x95\x94PPPPPV[_\x80a0\x9Aa0\x93\x84`HaA\xBDV[\x85\x90a3\x12V[`\xE8\x1C\x90P_\x84a0\xAC\x85`KaA\xBDV[\x81Q\x81\x10a0\xBCWa0\xBCa<|V[\x01` \x01Q`\xF8\x1C\x90P_a0\xEE\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a1\x01`\x03\x84aC\x91V[`\xFF\x16\x90Pa1\x12\x81a\x01\0aD\x8DV[a/\x8D\x90\x83a;UV[_a\n\xD0\x82\x84a;\x99V[_\x80a13\x85\x85a3\xA2V[\x90P\x82\x81\x14a1EW_\x91PPa\n\xD0V[P`\x01\x94\x93PPPPV[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[___a1\x82\x85\x85a3\xBAV[\x90P\x80`\xFF\x16_\x03a1\xB5W_\x85\x85\x81Q\x81\x10a1\xA1Wa1\xA1a<|V[\x01` \x01Q\x90\x93P`\xF8\x1C\x91Pa3\x0B\x90PV[\x83a1\xC1\x82`\x01aD\x98V[`\xFF\x16a1\xCE\x91\x90aA\xBDV[\x85Q\x10\x15a1\xE3W_\x19_\x92P\x92PPa3\x0BV[_\x81`\xFF\x16`\x02\x03a2&Wa2\x1Ba2\x07a2\0\x87`\x01aA\xBDV[\x88\x90a3\x12V[b\xFF\xFF\0`\xE8\x82\x90\x1C\x16`\xF8\x91\x90\x91\x1C\x17\x90V[a\xFF\xFF\x16\x90Pa3\x01V[\x81`\xFF\x16`\x04\x03a2uWa2ha2Ba2\0\x87`\x01aA\xBDV[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[c\xFF\xFF\xFF\xFF\x16\x90Pa3\x01V[\x81`\xFF\x16`\x08\x03a3\x01Wa2\xF4a2\x91a2\0\x87`\x01aA\xBDV[`\xC0\x1Cd\xFF\0\0\0\xFF`\x08\x82\x81\x1C\x91\x82\x16e\xFF\0\0\0\xFF\0\x93\x90\x91\x1B\x92\x83\x16\x17`\x10\x90\x81\x1Bg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16f\xFF\0\xFF\0\xFF\0\xFF\x92\x90\x92\x16g\xFF\0\xFF\0\xFF\0\xFF\0\x90\x93\x16\x92\x90\x92\x17\x90\x91\x1Ce\xFF\xFF\0\0\xFF\xFF\x16\x17` \x81\x81\x1C\x91\x90\x1B\x17\x90V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90P[`\xFF\x90\x91\x16\x92P\x90P[\x92P\x92\x90PV[_a\n\xD0\x83\x83\x01` \x01Q\x90V[``\x83\x15a3/WP\x81a\n\xD0V[\x82Q\x15a3?W\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x1Ei\x91\x90aD\xB1V[_\x80a3f\x83`%aA\xBDV[\x84Q\x10\x15a3yWP_\x19\x90P_a3\x0BV[_\x80a3\x8A\x86a+\xEB\x87`$aA\xBDV[\x90\x97\x90\x96P\x94PPPPPV[_a\n\xD0\x83\x83a4>V[_a\n\xD0a3\xB1\x83`\x04aA\xBDV[\x84\x01` \x01Q\x90V[_\x82\x82\x81Q\x81\x10a3\xCDWa3\xCDa<|V[\x01` \x01Q`\xF8\x1C`\xFF\x03a3\xE4WP`\x08a\x068V[\x82\x82\x81Q\x81\x10a3\xF6Wa3\xF6a<|V[\x01` \x01Q`\xF8\x1C`\xFE\x03a4\rWP`\x04a\x068V[\x82\x82\x81Q\x81\x10a4\x1FWa4\x1Fa<|V[\x01` \x01Q`\xF8\x1C`\xFD\x03a46WP`\x02a\x068V[P_\x92\x91PPV[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[`@Q\x80`\xA0\x01`@R\x80_\x81R` \x01a4\x8C`@Q\x80` \x01`@R\x80``\x81RP\x90V[\x81R_` \x82\x01\x81\x90R`@\x82\x01\x81\x90R``\x90\x91\x01R\x90V[P\x80Ta4\xB2\x90a<1V[_\x82U\x80`\x1F\x10a4\xC1WPPV[`\x1F\x01` \x90\x04\x90_R` _ \x90\x81\x01\x90a4\xDD\x91\x90a57V[PV[`@Q\x80a\x01\0\x01`@R\x80_\x81R` \x01a5\x08`@Q\x80` \x01`@R\x80``\x81RP\x90V[\x81R_` \x82\x01\x81\x90R`@\x82\x01\x81\x90R``\x82\x01\x81\x90R`\x80\x82\x01\x81\x90R`\xA0\x82\x01\x81\x90R`\xC0\x90\x91\x01R\x90V[[\x80\x82\x11\x15a5KW_\x81U`\x01\x01a58V[P\x90V[__`@\x83\x85\x03\x12\x15a5`W__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_\x81Q` \x84Ra\x1DZ` \x85\x01\x82a5oV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a5\xE1W\x81Q\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a5\xC3V[P\x93\x94\x93PPPPV[_`@\x82\x01`@\x83R\x80\x85Q\x80\x83R``\x85\x01\x91P``\x81`\x05\x1B\x86\x01\x01\x92P` \x87\x01_[\x82\x81\x10\x15a6\xADW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x87\x86\x03\x01\x84R\x81Q\x80Q\x86R` \x81\x01Q`\xA0` \x88\x01Ra6_`\xA0\x88\x01\x82a5\x9DV[\x90P`\x01`\x01`\xA0\x1B\x03`@\x83\x01Q\x16`@\x88\x01R``\x82\x01Q``\x88\x01R`\x01`\x01`\xA0\x1B\x03`\x80\x83\x01Q\x16`\x80\x88\x01R\x80\x96PPP` \x82\x01\x91P` \x84\x01\x93P`\x01\x81\x01\x90Pa6\x11V[PPPP\x82\x81\x03` \x84\x01Ra)J\x81\x85a5\xB1V[_` \x82\x84\x03\x12\x15a6\xD3W__\xFD[P\x91\x90PV[___``\x84\x86\x03\x12\x15a6\xEBW__\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a7\x08W__\xFD[a7\x14\x86\x82\x87\x01a6\xC3V[\x93\x96\x93\x95PPPP`@\x91\x90\x91\x015\x90V[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a7\x1CWa>\x1Ca<\x04V[a>0\x81a>*\x84Ta<1V[\x84a=\xBEV[` `\x1F\x82\x11`\x01\x81\x14a>bW_\x83\x15a>KWP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x1ErV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a>\x91W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a>qV[P\x84\x82\x10\x15a>\xAEW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[\x81\x83R\x81\x81` \x85\x017P_` \x82\x84\x01\x01R_` `\x1F\x19`\x1F\x84\x01\x16\x84\x01\x01\x90P\x92\x91PPV[_\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\xFF\xE1\x836\x03\x01\x81\x12a?\x18W__\xFD[\x82\x01` \x81\x01\x905g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a?4W__\xFD[\x806\x03\x82\x13\x15a?BW__\xFD[` \x85Ra)J` \x86\x01\x82\x84a>\xBDV[`\x80\x81R_a?f`\x80\x83\x01\x87a>\xE6V[` \x83\x01\x95\x90\x95RP`@\x81\x01\x92\x90\x92R`\x01`\x01`\xA0\x1B\x03\x16``\x90\x91\x01R\x91\x90PV[\x84\x81R`\x80` \x82\x01R_a?\xA3`\x80\x83\x01\x86a>\xE6V[`\x01`\x01`\xA0\x1B\x03\x94\x90\x94\x16`@\x83\x01RP``\x01R\x92\x91PPV[__\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?\xF2W__\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a@\x0CW__\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a3\x0BW__\xFD[` \x81R_a\x1DZ` \x83\x01\x84\x86a>\xBDV[\x805\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\x14a7W__\xFD[aAJ6\x82\x86\x01a<\xD2V[\x82RP` \x83\x81\x015\x90\x82\x01R`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aApW__\xFD[aA|6\x82\x86\x01a<\xD2V[`@\x83\x01RP``\x83\x81\x015\x90\x82\x01R`\x80\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15aA\xA5W__\xFD[aA\xB16\x82\x86\x01a<\xD2V[`\x80\x83\x01RP\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x068Wa\x068a;(V[\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\x83`\xF8\x1B\x16\x81R__\x83TaB\x05\x81a<1V[`\x01\x82\x16\x80\x15aB\x1CW`\x01\x81\x14aBUWaB\x8BV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x83\x16`\x01\x87\x01R`\x01\x82\x15\x15\x83\x02\x87\x01\x01\x93PaB\x8BV[\x86_R` _ _[\x83\x81\x10\x15aB\x80W\x81T`\x01\x82\x8A\x01\x01R`\x01\x82\x01\x91P` \x81\x01\x90PaB^V[PP`\x01\x82\x87\x01\x01\x93P[P\x91\x96\x95PPPPPPV[_` \x82\x84\x03\x12\x15aB\xA7W__\xFD[\x81Q\x80\x15\x15\x81\x14a\n\xD0W__\xFD[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[\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\x85\x16\x81R_aC\taC\x03`\x04\x84\x01\x87aB\xB6V[\x85aB\xB6V[\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\x93\x90\x93\x16\x83RPP`\x04\x01\x93\x92PPPV[_a\n\xD0\x82\x84aB\xB6V[_` \x82\x84\x03\x12\x15aCWW__\xFD[PQ\x91\x90PV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x068Wa\x068a;(V[_\x82aC\x8CWaC\x8Ca;lV[P\x06\x90V[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x068Wa\x068a;(V[`\x01\x81[`\x01\x84\x11\x15aC\xE5W\x80\x85\x04\x81\x11\x15aC\xC9WaC\xC9a;(V[`\x01\x84\x16\x15aC\xD7W\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02aC\xAEV[\x93P\x93\x91PPV[_\x82aC\xFBWP`\x01a\x068V[\x81aD\x07WP_a\x068V[\x81`\x01\x81\x14aD\x1DW`\x02\x81\x14aD'WaDCV[`\x01\x91PPa\x068V[`\xFF\x84\x11\x15aD8WaD8a;(V[PP`\x01\x82\x1Ba\x068V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15aDfWP\x81\x81\na\x068V[aDr_\x19\x84\x84aC\xAAV[\x80_\x19\x04\x82\x11\x15aD\x85WaD\x85a;(V[\x02\x93\x92PPPV[_a\n\xD0\x83\x83aC\xEDV[`\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x068Wa\x068a;(V[` \x81R_a\n\xD0` \x83\x01\x84a5oV\xFE\xA2dipfsX\"\x12 A\xDF\x18\xE5x\xA0A\xC2\xE5-\x8F\x05\xEBc;\xA9l\0\x11;`\x87?x\xCB\xE1J\xFF\x1C\xB1\x7F\x07dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct AcceptedBtcBuyOrder { uint256 orderId; uint256 amountBtc; address ercToken; uint256 ercAmount; address requester; address accepter; uint256 acceptTime; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct AcceptedBtcBuyOrder { - #[allow(missing_docs)] - pub orderId: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub ercToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub ercAmount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub requester: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub accepter: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub acceptTime: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - 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::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::Address, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: AcceptedBtcBuyOrder) -> Self { - ( - value.orderId, - value.amountBtc, - value.ercToken, - value.ercAmount, - value.requester, - value.accepter, - value.acceptTime, - ) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for AcceptedBtcBuyOrder { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - orderId: tuple.0, - amountBtc: tuple.1, - ercToken: tuple.2, - ercAmount: tuple.3, - requester: tuple.4, - accepter: tuple.5, - acceptTime: tuple.6, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for AcceptedBtcBuyOrder { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for AcceptedBtcBuyOrder { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.orderId), - as alloy_sol_types::SolType>::tokenize(&self.amountBtc), - ::tokenize( - &self.ercToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.ercAmount), - ::tokenize( - &self.requester, - ), - ::tokenize( - &self.accepter, - ), - as alloy_sol_types::SolType>::tokenize(&self.acceptTime), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for AcceptedBtcBuyOrder { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for AcceptedBtcBuyOrder { - const NAME: &'static str = "AcceptedBtcBuyOrder"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "AcceptedBtcBuyOrder(uint256 orderId,uint256 amountBtc,address ercToken,uint256 ercAmount,address requester,address accepter,uint256 acceptTime)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - as alloy_sol_types::SolType>::eip712_data_word(&self.orderId) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.amountBtc) - .0, - ::eip712_data_word( - &self.ercToken, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.ercAmount) - .0, - ::eip712_data_word( - &self.requester, - ) - .0, - ::eip712_data_word( - &self.accepter, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.acceptTime) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for AcceptedBtcBuyOrder { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.orderId, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.amountBtc, - ) - + ::topic_preimage_length( - &rust.ercToken, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.ercAmount, - ) - + ::topic_preimage_length( - &rust.requester, - ) - + ::topic_preimage_length( - &rust.accepter, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.acceptTime, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.orderId, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.amountBtc, - out, - ); - ::encode_topic_preimage( - &rust.ercToken, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.ercAmount, - out, - ); - ::encode_topic_preimage( - &rust.requester, - out, - ); - ::encode_topic_preimage( - &rust.accepter, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.acceptTime, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct AcceptedBtcSellOrder { uint256 orderId; BitcoinAddress bitcoinAddress; uint256 amountBtc; address ercToken; uint256 ercAmount; address requester; address accepter; uint256 acceptTime; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct AcceptedBtcSellOrder { - #[allow(missing_docs)] - pub orderId: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub bitcoinAddress: ::RustType, - #[allow(missing_docs)] - pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub ercToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub ercAmount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub requester: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub accepter: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub acceptTime: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - BitcoinAddress, - 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::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ::RustType, - alloy::sol_types::private::primitives::aliases::U256, - alloy::sol_types::private::Address, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: AcceptedBtcSellOrder) -> Self { - ( - value.orderId, - value.bitcoinAddress, - value.amountBtc, - value.ercToken, - value.ercAmount, - value.requester, - value.accepter, - value.acceptTime, - ) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for AcceptedBtcSellOrder { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - orderId: tuple.0, - bitcoinAddress: tuple.1, - amountBtc: tuple.2, - ercToken: tuple.3, - ercAmount: tuple.4, - requester: tuple.5, - accepter: tuple.6, - acceptTime: tuple.7, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for AcceptedBtcSellOrder { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for AcceptedBtcSellOrder { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.orderId), - ::tokenize( - &self.bitcoinAddress, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountBtc), - ::tokenize( - &self.ercToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.ercAmount), - ::tokenize( - &self.requester, - ), - ::tokenize( - &self.accepter, - ), - as alloy_sol_types::SolType>::tokenize(&self.acceptTime), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for AcceptedBtcSellOrder { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for AcceptedBtcSellOrder { - const NAME: &'static str = "AcceptedBtcSellOrder"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "AcceptedBtcSellOrder(uint256 orderId,BitcoinAddress bitcoinAddress,uint256 amountBtc,address ercToken,uint256 ercAmount,address requester,address accepter,uint256 acceptTime)", - ) - } - #[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( - ::eip712_root_type(), - ); - components - .extend( - ::eip712_components(), - ); - components - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - as alloy_sol_types::SolType>::eip712_data_word(&self.orderId) - .0, - ::eip712_data_word( - &self.bitcoinAddress, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.amountBtc) - .0, - ::eip712_data_word( - &self.ercToken, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.ercAmount) - .0, - ::eip712_data_word( - &self.requester, - ) - .0, - ::eip712_data_word( - &self.accepter, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.acceptTime) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for AcceptedBtcSellOrder { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.orderId, - ) - + ::topic_preimage_length( - &rust.bitcoinAddress, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.amountBtc, - ) - + ::topic_preimage_length( - &rust.ercToken, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.ercAmount, - ) - + ::topic_preimage_length( - &rust.requester, - ) - + ::topic_preimage_length( - &rust.accepter, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.acceptTime, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.orderId, - out, - ); - ::encode_topic_preimage( - &rust.bitcoinAddress, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.amountBtc, - out, - ); - ::encode_topic_preimage( - &rust.ercToken, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.ercAmount, - out, - ); - ::encode_topic_preimage( - &rust.requester, - out, - ); - ::encode_topic_preimage( - &rust.accepter, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.acceptTime, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct BitcoinAddress { bytes scriptPubKey; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct BitcoinAddress { - #[allow(missing_docs)] - pub scriptPubKey: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: BitcoinAddress) -> Self { - (value.scriptPubKey,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for BitcoinAddress { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { scriptPubKey: tuple.0 } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for BitcoinAddress { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for BitcoinAddress { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.scriptPubKey, - ), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for BitcoinAddress { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for BitcoinAddress { - const NAME: &'static str = "BitcoinAddress"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "BitcoinAddress(bytes scriptPubKey)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - ::eip712_data_word( - &self.scriptPubKey, - ) - .0 - .to_vec() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for BitcoinAddress { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.scriptPubKey, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.scriptPubKey, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct BtcBuyOrder { uint256 amountBtc; BitcoinAddress bitcoinAddress; address offeringToken; uint256 offeringAmount; address requester; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct BtcBuyOrder { - #[allow(missing_docs)] - pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub bitcoinAddress: ::RustType, - #[allow(missing_docs)] - pub offeringToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub offeringAmount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub requester: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - BitcoinAddress, - 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, - ::RustType, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: BtcBuyOrder) -> Self { - ( - value.amountBtc, - value.bitcoinAddress, - value.offeringToken, - value.offeringAmount, - value.requester, - ) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for BtcBuyOrder { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - amountBtc: tuple.0, - bitcoinAddress: tuple.1, - offeringToken: tuple.2, - offeringAmount: tuple.3, - requester: tuple.4, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for BtcBuyOrder { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for BtcBuyOrder { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountBtc), - ::tokenize( - &self.bitcoinAddress, - ), - ::tokenize( - &self.offeringToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.offeringAmount), - ::tokenize( - &self.requester, - ), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for BtcBuyOrder { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for BtcBuyOrder { - const NAME: &'static str = "BtcBuyOrder"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "BtcBuyOrder(uint256 amountBtc,BitcoinAddress bitcoinAddress,address offeringToken,uint256 offeringAmount,address requester)", - ) - } - #[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( - ::eip712_root_type(), - ); - components - .extend( - ::eip712_components(), - ); - components - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - as alloy_sol_types::SolType>::eip712_data_word(&self.amountBtc) - .0, - ::eip712_data_word( - &self.bitcoinAddress, - ) - .0, - ::eip712_data_word( - &self.offeringToken, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word( - &self.offeringAmount, - ) - .0, - ::eip712_data_word( - &self.requester, - ) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for BtcBuyOrder { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.amountBtc, - ) - + ::topic_preimage_length( - &rust.bitcoinAddress, - ) - + ::topic_preimage_length( - &rust.offeringToken, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.offeringAmount, - ) - + ::topic_preimage_length( - &rust.requester, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.amountBtc, - out, - ); - ::encode_topic_preimage( - &rust.bitcoinAddress, - out, - ); - ::encode_topic_preimage( - &rust.offeringToken, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.offeringAmount, - out, - ); - ::encode_topic_preimage( - &rust.requester, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct BtcSellOrder { uint256 amountBtc; address askingToken; uint256 askingAmount; address requester; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct BtcSellOrder { - #[allow(missing_docs)] - pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub askingToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub askingAmount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub requester: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - 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, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: BtcSellOrder) -> Self { - (value.amountBtc, value.askingToken, value.askingAmount, value.requester) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for BtcSellOrder { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - amountBtc: tuple.0, - askingToken: tuple.1, - askingAmount: tuple.2, - requester: tuple.3, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for BtcSellOrder { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for BtcSellOrder { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountBtc), - ::tokenize( - &self.askingToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.askingAmount), - ::tokenize( - &self.requester, - ), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for BtcSellOrder { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for BtcSellOrder { - const NAME: &'static str = "BtcSellOrder"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "BtcSellOrder(uint256 amountBtc,address askingToken,uint256 askingAmount,address requester)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - as alloy_sol_types::SolType>::eip712_data_word(&self.amountBtc) - .0, - ::eip712_data_word( - &self.askingToken, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.askingAmount) - .0, - ::eip712_data_word( - &self.requester, - ) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for BtcSellOrder { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.amountBtc, - ) - + ::topic_preimage_length( - &rust.askingToken, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.askingAmount, - ) - + ::topic_preimage_length( - &rust.requester, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.amountBtc, - out, - ); - ::encode_topic_preimage( - &rust.askingToken, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.askingAmount, - out, - ); - ::encode_topic_preimage( - &rust.requester, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `acceptBtcBuyOrderEvent(uint256,uint256,uint256,uint256,address)` and selector `0xc39a1a5ddc0e85c955fe2e1abeb43c94ce18322e75bb3d44e80f759ff9d034b9`. -```solidity -event acceptBtcBuyOrderEvent(uint256 indexed orderId, uint256 indexed acceptId, uint256 amountBtc, uint256 ercAmount, address ercToken); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct acceptBtcBuyOrderEvent { - #[allow(missing_docs)] - pub orderId: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub acceptId: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub ercAmount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub ercToken: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for acceptBtcBuyOrderEvent { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - const SIGNATURE: &'static str = "acceptBtcBuyOrderEvent(uint256,uint256,uint256,uint256,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 195u8, 154u8, 26u8, 93u8, 220u8, 14u8, 133u8, 201u8, 85u8, 254u8, 46u8, - 26u8, 190u8, 180u8, 60u8, 148u8, 206u8, 24u8, 50u8, 46u8, 117u8, 187u8, - 61u8, 68u8, 232u8, 15u8, 117u8, 159u8, 249u8, 208u8, 52u8, 185u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - orderId: topics.1, - acceptId: topics.2, - amountBtc: data.0, - ercAmount: data.1, - ercToken: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountBtc), - as alloy_sol_types::SolType>::tokenize(&self.ercAmount), - ::tokenize( - &self.ercToken, - ), - ) - } - #[inline] - fn topics(&self) -> ::RustType { - ( - Self::SIGNATURE_HASH.into(), - self.orderId.clone(), - self.acceptId.clone(), - ) - } - #[inline] - fn encode_topics_raw( - &self, - out: &mut [alloy_sol_types::abi::token::WordToken], - ) -> alloy_sol_types::Result<()> { - if out.len() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.orderId); - out[2usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.acceptId); - Ok(()) - } - } - #[automatically_derived] - impl alloy_sol_types::private::IntoLogData for acceptBtcBuyOrderEvent { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&acceptBtcBuyOrderEvent> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &acceptBtcBuyOrderEvent) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `acceptBtcSellOrderEvent(uint256,uint256,(bytes),uint256,uint256,address)` and selector `0x653e0d81f2c99beba359dfb17b499a5cff2be9d950514852224df8c097c21921`. -```solidity -event acceptBtcSellOrderEvent(uint256 indexed id, uint256 indexed acceptId, BitcoinAddress bitcoinAddress, uint256 amountBtc, uint256 ercAmount, address ercToken); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct acceptBtcSellOrderEvent { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub acceptId: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub bitcoinAddress: ::RustType, - #[allow(missing_docs)] - pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub ercAmount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub ercToken: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for acceptBtcSellOrderEvent { - type DataTuple<'a> = ( - BitcoinAddress, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - const SIGNATURE: &'static str = "acceptBtcSellOrderEvent(uint256,uint256,(bytes),uint256,uint256,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 101u8, 62u8, 13u8, 129u8, 242u8, 201u8, 155u8, 235u8, 163u8, 89u8, 223u8, - 177u8, 123u8, 73u8, 154u8, 92u8, 255u8, 43u8, 233u8, 217u8, 80u8, 81u8, - 72u8, 82u8, 34u8, 77u8, 248u8, 192u8, 151u8, 194u8, 25u8, 33u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - id: topics.1, - acceptId: topics.2, - bitcoinAddress: data.0, - amountBtc: data.1, - ercAmount: data.2, - ercToken: data.3, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.bitcoinAddress, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountBtc), - as alloy_sol_types::SolType>::tokenize(&self.ercAmount), - ::tokenize( - &self.ercToken, - ), - ) - } - #[inline] - fn topics(&self) -> ::RustType { - (Self::SIGNATURE_HASH.into(), self.id.clone(), self.acceptId.clone()) - } - #[inline] - fn encode_topics_raw( - &self, - out: &mut [alloy_sol_types::abi::token::WordToken], - ) -> alloy_sol_types::Result<()> { - if out.len() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.id); - out[2usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.acceptId); - Ok(()) - } - } - #[automatically_derived] - impl alloy_sol_types::private::IntoLogData for acceptBtcSellOrderEvent { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&acceptBtcSellOrderEvent> for alloy_sol_types::private::LogData { - #[inline] - fn from( - this: &acceptBtcSellOrderEvent, - ) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `cancelAcceptedBtcBuyOrderEvent(uint256)` and selector `0x3e5ea358e9eb4cdf44cdc77938ade8074b1240a6d8c0fd13728671b82e800ad6`. -```solidity -event cancelAcceptedBtcBuyOrderEvent(uint256 id); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct cancelAcceptedBtcBuyOrderEvent { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for cancelAcceptedBtcBuyOrderEvent { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "cancelAcceptedBtcBuyOrderEvent(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 62u8, 94u8, 163u8, 88u8, 233u8, 235u8, 76u8, 223u8, 68u8, 205u8, 199u8, - 121u8, 56u8, 173u8, 232u8, 7u8, 75u8, 18u8, 64u8, 166u8, 216u8, 192u8, - 253u8, 19u8, 114u8, 134u8, 113u8, 184u8, 46u8, 128u8, 10u8, 214u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { id: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 cancelAcceptedBtcBuyOrderEvent { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&cancelAcceptedBtcBuyOrderEvent> - for alloy_sol_types::private::LogData { - #[inline] - fn from( - this: &cancelAcceptedBtcBuyOrderEvent, - ) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `cancelAcceptedBtcSellOrderEvent(uint256)` and selector `0x78f51f62f7cf1381c673c27eae187dd6c588dc6624ce59697dbb3e1d7c1bbcdf`. -```solidity -event cancelAcceptedBtcSellOrderEvent(uint256 id); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct cancelAcceptedBtcSellOrderEvent { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for cancelAcceptedBtcSellOrderEvent { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "cancelAcceptedBtcSellOrderEvent(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 120u8, 245u8, 31u8, 98u8, 247u8, 207u8, 19u8, 129u8, 198u8, 115u8, 194u8, - 126u8, 174u8, 24u8, 125u8, 214u8, 197u8, 136u8, 220u8, 102u8, 36u8, - 206u8, 89u8, 105u8, 125u8, 187u8, 62u8, 29u8, 124u8, 27u8, 188u8, 223u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { id: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 cancelAcceptedBtcSellOrderEvent { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&cancelAcceptedBtcSellOrderEvent> - for alloy_sol_types::private::LogData { - #[inline] - fn from( - this: &cancelAcceptedBtcSellOrderEvent, - ) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `placeBtcBuyOrderEvent(uint256,(bytes),address,uint256)` and selector `0x98c7c680403d47403dea4a570d0e6c5716538c49420ef471cec428f5a5852c06`. -```solidity -event placeBtcBuyOrderEvent(uint256 amountBtc, BitcoinAddress bitcoinAddress, address sellingToken, uint256 saleAmount); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct placeBtcBuyOrderEvent { - #[allow(missing_docs)] - pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub bitcoinAddress: ::RustType, - #[allow(missing_docs)] - pub sellingToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub saleAmount: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for placeBtcBuyOrderEvent { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - BitcoinAddress, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "placeBtcBuyOrderEvent(uint256,(bytes),address,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 152u8, 199u8, 198u8, 128u8, 64u8, 61u8, 71u8, 64u8, 61u8, 234u8, 74u8, - 87u8, 13u8, 14u8, 108u8, 87u8, 22u8, 83u8, 140u8, 73u8, 66u8, 14u8, - 244u8, 113u8, 206u8, 196u8, 40u8, 245u8, 165u8, 133u8, 44u8, 6u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - amountBtc: data.0, - bitcoinAddress: data.1, - sellingToken: data.2, - saleAmount: data.3, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountBtc), - ::tokenize( - &self.bitcoinAddress, - ), - ::tokenize( - &self.sellingToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.saleAmount), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 placeBtcBuyOrderEvent { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&placeBtcBuyOrderEvent> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &placeBtcBuyOrderEvent) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `placeBtcSellOrderEvent(uint256,uint256,address,uint256)` and selector `0xff1ce210defcd3ba1adf76c9419a0758fa60fd3eb38c7bd9418f60b575b76e24`. -```solidity -event placeBtcSellOrderEvent(uint256 indexed orderId, uint256 amountBtc, address buyingToken, uint256 buyAmount); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct placeBtcSellOrderEvent { - #[allow(missing_docs)] - pub orderId: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub buyingToken: alloy::sol_types::private::Address, - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for placeBtcSellOrderEvent { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Uint<256>, - ); - const SIGNATURE: &'static str = "placeBtcSellOrderEvent(uint256,uint256,address,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 255u8, 28u8, 226u8, 16u8, 222u8, 252u8, 211u8, 186u8, 26u8, 223u8, 118u8, - 201u8, 65u8, 154u8, 7u8, 88u8, 250u8, 96u8, 253u8, 62u8, 179u8, 140u8, - 123u8, 217u8, 65u8, 143u8, 96u8, 181u8, 117u8, 183u8, 110u8, 36u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - orderId: topics.1, - amountBtc: data.0, - buyingToken: data.1, - buyAmount: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountBtc), - ::tokenize( - &self.buyingToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.buyAmount), - ) - } - #[inline] - fn topics(&self) -> ::RustType { - (Self::SIGNATURE_HASH.into(), self.orderId.clone()) - } - #[inline] - fn encode_topics_raw( - &self, - out: &mut [alloy_sol_types::abi::token::WordToken], - ) -> alloy_sol_types::Result<()> { - if out.len() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.orderId); - Ok(()) - } - } - #[automatically_derived] - impl alloy_sol_types::private::IntoLogData for placeBtcSellOrderEvent { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&placeBtcSellOrderEvent> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &placeBtcSellOrderEvent) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `proofBtcBuyOrderEvent(uint256)` and selector `0xb4c98de210696b3cf21e99335c1ee3a0ae34a26713412a4adde8af596176f37e`. -```solidity -event proofBtcBuyOrderEvent(uint256 id); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct proofBtcBuyOrderEvent { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for proofBtcBuyOrderEvent { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "proofBtcBuyOrderEvent(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 180u8, 201u8, 141u8, 226u8, 16u8, 105u8, 107u8, 60u8, 242u8, 30u8, 153u8, - 51u8, 92u8, 30u8, 227u8, 160u8, 174u8, 52u8, 162u8, 103u8, 19u8, 65u8, - 42u8, 74u8, 221u8, 232u8, 175u8, 89u8, 97u8, 118u8, 243u8, 126u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { id: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 proofBtcBuyOrderEvent { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&proofBtcBuyOrderEvent> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &proofBtcBuyOrderEvent) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `proofBtcSellOrderEvent(uint256)` and selector `0xcf561061db78f7bc518d37fe86718514c640ccc5c3f1293828b955e68f19f5fb`. -```solidity -event proofBtcSellOrderEvent(uint256 id); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct proofBtcSellOrderEvent { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for proofBtcSellOrderEvent { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "proofBtcSellOrderEvent(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 207u8, 86u8, 16u8, 97u8, 219u8, 120u8, 247u8, 188u8, 81u8, 141u8, 55u8, - 254u8, 134u8, 113u8, 133u8, 20u8, 198u8, 64u8, 204u8, 197u8, 195u8, - 241u8, 41u8, 56u8, 40u8, 185u8, 85u8, 230u8, 143u8, 25u8, 245u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { id: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 proofBtcSellOrderEvent { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&proofBtcSellOrderEvent> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &proofBtcSellOrderEvent) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `withdrawBtcBuyOrderEvent(uint256)` and selector `0xc340e7ac48dc80ee793fc6266960bd5f1bd21be91c8a95e218178113f79e17b4`. -```solidity -event withdrawBtcBuyOrderEvent(uint256 id); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct withdrawBtcBuyOrderEvent { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for withdrawBtcBuyOrderEvent { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "withdrawBtcBuyOrderEvent(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 195u8, 64u8, 231u8, 172u8, 72u8, 220u8, 128u8, 238u8, 121u8, 63u8, 198u8, - 38u8, 105u8, 96u8, 189u8, 95u8, 27u8, 210u8, 27u8, 233u8, 28u8, 138u8, - 149u8, 226u8, 24u8, 23u8, 129u8, 19u8, 247u8, 158u8, 23u8, 180u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { id: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 withdrawBtcBuyOrderEvent { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&withdrawBtcBuyOrderEvent> for alloy_sol_types::private::LogData { - #[inline] - fn from( - this: &withdrawBtcBuyOrderEvent, - ) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `withdrawBtcSellOrderEvent(uint256)` and selector `0x3cd475b092e8b379f6ba0d9e0e0c8f30705e73321dc5c9f80ce4ad38db7be1aa`. -```solidity -event withdrawBtcSellOrderEvent(uint256 id); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct withdrawBtcSellOrderEvent { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for withdrawBtcSellOrderEvent { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "withdrawBtcSellOrderEvent(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 60u8, 212u8, 117u8, 176u8, 146u8, 232u8, 179u8, 121u8, 246u8, 186u8, - 13u8, 158u8, 14u8, 12u8, 143u8, 48u8, 112u8, 94u8, 115u8, 50u8, 29u8, - 197u8, 201u8, 248u8, 12u8, 228u8, 173u8, 56u8, 219u8, 123u8, 225u8, 170u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { id: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 withdrawBtcSellOrderEvent { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&withdrawBtcSellOrderEvent> for alloy_sol_types::private::LogData { - #[inline] - fn from( - this: &withdrawBtcSellOrderEvent, - ) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - /**Constructor`. -```solidity -constructor(address _relay, address erc2771Forwarder); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct constructorCall { - #[allow(missing_docs)] - pub _relay: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub erc2771Forwarder: alloy::sol_types::private::Address, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value._relay, value.erc2771Forwarder) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - _relay: tuple.0, - erc2771Forwarder: 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> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._relay, - ), - ::tokenize( - &self.erc2771Forwarder, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `REQUEST_EXPIRATION_SECONDS()` and selector `0xd1920ff0`. -```solidity -function REQUEST_EXPIRATION_SECONDS() external view returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct REQUEST_EXPIRATION_SECONDSCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`REQUEST_EXPIRATION_SECONDS()`](REQUEST_EXPIRATION_SECONDSCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct REQUEST_EXPIRATION_SECONDSReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: REQUEST_EXPIRATION_SECONDSCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for REQUEST_EXPIRATION_SECONDSCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: REQUEST_EXPIRATION_SECONDSReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for REQUEST_EXPIRATION_SECONDSReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for REQUEST_EXPIRATION_SECONDSCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "REQUEST_EXPIRATION_SECONDS()"; - const SELECTOR: [u8; 4] = [209u8, 146u8, 15u8, 240u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: REQUEST_EXPIRATION_SECONDSReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: REQUEST_EXPIRATION_SECONDSReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `acceptBtcBuyOrder(uint256,uint256)` and selector `0x11c137aa`. -```solidity -function acceptBtcBuyOrder(uint256 id, uint256 amountBtc) external returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct acceptBtcBuyOrderCall { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`acceptBtcBuyOrder(uint256,uint256)`](acceptBtcBuyOrderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct acceptBtcBuyOrderReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: acceptBtcBuyOrderCall) -> Self { - (value.id, value.amountBtc) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for acceptBtcBuyOrderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - id: tuple.0, - amountBtc: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: acceptBtcBuyOrderReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for acceptBtcBuyOrderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for acceptBtcBuyOrderCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "acceptBtcBuyOrder(uint256,uint256)"; - const SELECTOR: [u8; 4] = [17u8, 193u8, 55u8, 170u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - as alloy_sol_types::SolType>::tokenize(&self.amountBtc), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: acceptBtcBuyOrderReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: acceptBtcBuyOrderReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `acceptBtcSellOrder(uint256,(bytes),uint256)` and selector `0x210ec181`. -```solidity -function acceptBtcSellOrder(uint256 id, BitcoinAddress memory bitcoinAddress, uint256 amountBtc) external returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct acceptBtcSellOrderCall { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub bitcoinAddress: ::RustType, - #[allow(missing_docs)] - pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`acceptBtcSellOrder(uint256,(bytes),uint256)`](acceptBtcSellOrderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct acceptBtcSellOrderReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - BitcoinAddress, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ::RustType, - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: acceptBtcSellOrderCall) -> Self { - (value.id, value.bitcoinAddress, value.amountBtc) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for acceptBtcSellOrderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - id: tuple.0, - bitcoinAddress: tuple.1, - amountBtc: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: acceptBtcSellOrderReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for acceptBtcSellOrderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for acceptBtcSellOrderCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - BitcoinAddress, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "acceptBtcSellOrder(uint256,(bytes),uint256)"; - const SELECTOR: [u8; 4] = [33u8, 14u8, 193u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - ::tokenize( - &self.bitcoinAddress, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountBtc), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: acceptBtcSellOrderReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: acceptBtcSellOrderReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `acceptedBtcBuyOrders(uint256)` and selector `0xbd2a7e3e`. -```solidity -function acceptedBtcBuyOrders(uint256) external view returns (uint256 orderId, uint256 amountBtc, address ercToken, uint256 ercAmount, address requester, address accepter, uint256 acceptTime); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct acceptedBtcBuyOrdersCall( - pub alloy::sol_types::private::primitives::aliases::U256, - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`acceptedBtcBuyOrders(uint256)`](acceptedBtcBuyOrdersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct acceptedBtcBuyOrdersReturn { - #[allow(missing_docs)] - pub orderId: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub ercToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub ercAmount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub requester: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub accepter: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub acceptTime: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: acceptedBtcBuyOrdersCall) -> Self { - (value.0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for acceptedBtcBuyOrdersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self(tuple.0) - } - } - } - { - #[doc(hidden)] - 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::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::Address, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: acceptedBtcBuyOrdersReturn) -> Self { - ( - value.orderId, - value.amountBtc, - value.ercToken, - value.ercAmount, - value.requester, - value.accepter, - value.acceptTime, - ) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for acceptedBtcBuyOrdersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - orderId: tuple.0, - amountBtc: tuple.1, - ercToken: tuple.2, - ercAmount: tuple.3, - requester: tuple.4, - accepter: tuple.5, - acceptTime: tuple.6, - } - } - } - } - impl acceptedBtcBuyOrdersReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - ( - as alloy_sol_types::SolType>::tokenize(&self.orderId), - as alloy_sol_types::SolType>::tokenize(&self.amountBtc), - ::tokenize( - &self.ercToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.ercAmount), - ::tokenize( - &self.requester, - ), - ::tokenize( - &self.accepter, - ), - as alloy_sol_types::SolType>::tokenize(&self.acceptTime), - ) - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for acceptedBtcBuyOrdersCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = acceptedBtcBuyOrdersReturn; - type ReturnTuple<'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::Address, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "acceptedBtcBuyOrders(uint256)"; - const SELECTOR: [u8; 4] = [189u8, 42u8, 126u8, 62u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.0), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - acceptedBtcBuyOrdersReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `acceptedBtcSellOrders(uint256)` and selector `0x4145640a`. -```solidity -function acceptedBtcSellOrders(uint256) external view returns (uint256 orderId, BitcoinAddress memory bitcoinAddress, uint256 amountBtc, address ercToken, uint256 ercAmount, address requester, address accepter, uint256 acceptTime); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct acceptedBtcSellOrdersCall( - pub alloy::sol_types::private::primitives::aliases::U256, - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`acceptedBtcSellOrders(uint256)`](acceptedBtcSellOrdersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct acceptedBtcSellOrdersReturn { - #[allow(missing_docs)] - pub orderId: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub bitcoinAddress: ::RustType, - #[allow(missing_docs)] - pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub ercToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub ercAmount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub requester: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub accepter: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub acceptTime: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: acceptedBtcSellOrdersCall) -> Self { - (value.0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for acceptedBtcSellOrdersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self(tuple.0) - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - BitcoinAddress, - 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::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ::RustType, - alloy::sol_types::private::primitives::aliases::U256, - alloy::sol_types::private::Address, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: acceptedBtcSellOrdersReturn) -> Self { - ( - value.orderId, - value.bitcoinAddress, - value.amountBtc, - value.ercToken, - value.ercAmount, - value.requester, - value.accepter, - value.acceptTime, - ) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for acceptedBtcSellOrdersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - orderId: tuple.0, - bitcoinAddress: tuple.1, - amountBtc: tuple.2, - ercToken: tuple.3, - ercAmount: tuple.4, - requester: tuple.5, - accepter: tuple.6, - acceptTime: tuple.7, - } - } - } - } - impl acceptedBtcSellOrdersReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - ( - as alloy_sol_types::SolType>::tokenize(&self.orderId), - ::tokenize( - &self.bitcoinAddress, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountBtc), - ::tokenize( - &self.ercToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.ercAmount), - ::tokenize( - &self.requester, - ), - ::tokenize( - &self.accepter, - ), - as alloy_sol_types::SolType>::tokenize(&self.acceptTime), - ) - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for acceptedBtcSellOrdersCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = acceptedBtcSellOrdersReturn; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - BitcoinAddress, - 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::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "acceptedBtcSellOrders(uint256)"; - const SELECTOR: [u8; 4] = [65u8, 69u8, 100u8, 10u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.0), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - acceptedBtcSellOrdersReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `btcBuyOrders(uint256)` and selector `0x3af3fc7e`. -```solidity -function btcBuyOrders(uint256) external view returns (uint256 amountBtc, BitcoinAddress memory bitcoinAddress, address offeringToken, uint256 offeringAmount, address requester); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct btcBuyOrdersCall( - pub alloy::sol_types::private::primitives::aliases::U256, - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`btcBuyOrders(uint256)`](btcBuyOrdersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct btcBuyOrdersReturn { - #[allow(missing_docs)] - pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub bitcoinAddress: ::RustType, - #[allow(missing_docs)] - pub offeringToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub offeringAmount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub requester: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: btcBuyOrdersCall) -> Self { - (value.0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for btcBuyOrdersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self(tuple.0) - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - BitcoinAddress, - 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, - ::RustType, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: btcBuyOrdersReturn) -> Self { - ( - value.amountBtc, - value.bitcoinAddress, - value.offeringToken, - value.offeringAmount, - value.requester, - ) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for btcBuyOrdersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - amountBtc: tuple.0, - bitcoinAddress: tuple.1, - offeringToken: tuple.2, - offeringAmount: tuple.3, - requester: tuple.4, - } - } - } - } - impl btcBuyOrdersReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountBtc), - ::tokenize( - &self.bitcoinAddress, - ), - ::tokenize( - &self.offeringToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.offeringAmount), - ::tokenize( - &self.requester, - ), - ) - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for btcBuyOrdersCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = btcBuyOrdersReturn; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - BitcoinAddress, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "btcBuyOrders(uint256)"; - const SELECTOR: [u8; 4] = [58u8, 243u8, 252u8, 126u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.0), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - btcBuyOrdersReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `btcSellOrders(uint256)` and selector `0xecca2c36`. -```solidity -function btcSellOrders(uint256) external view returns (uint256 amountBtc, address askingToken, uint256 askingAmount, address requester); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct btcSellOrdersCall( - pub alloy::sol_types::private::primitives::aliases::U256, - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`btcSellOrders(uint256)`](btcSellOrdersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct btcSellOrdersReturn { - #[allow(missing_docs)] - pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub askingToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub askingAmount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub requester: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: btcSellOrdersCall) -> Self { - (value.0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for btcSellOrdersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self(tuple.0) - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - 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, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: btcSellOrdersReturn) -> Self { - ( - value.amountBtc, - value.askingToken, - value.askingAmount, - value.requester, - ) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for btcSellOrdersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - amountBtc: tuple.0, - askingToken: tuple.1, - askingAmount: tuple.2, - requester: tuple.3, - } - } - } - } - impl btcSellOrdersReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountBtc), - ::tokenize( - &self.askingToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.askingAmount), - ::tokenize( - &self.requester, - ), - ) - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for btcSellOrdersCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = btcSellOrdersReturn; - type ReturnTuple<'a> = ( - 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 ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "btcSellOrders(uint256)"; - const SELECTOR: [u8; 4] = [236u8, 202u8, 44u8, 54u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.0), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - btcSellOrdersReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `cancelAcceptedBtcBuyOrder(uint256)` and selector `0xc56a4526`. -```solidity -function cancelAcceptedBtcBuyOrder(uint256 id) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct cancelAcceptedBtcBuyOrderCall { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - } - ///Container type for the return parameters of the [`cancelAcceptedBtcBuyOrder(uint256)`](cancelAcceptedBtcBuyOrderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct cancelAcceptedBtcBuyOrderReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: cancelAcceptedBtcBuyOrderCall) -> Self { - (value.id,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for cancelAcceptedBtcBuyOrderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { id: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: cancelAcceptedBtcBuyOrderReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for cancelAcceptedBtcBuyOrderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl cancelAcceptedBtcBuyOrderReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for cancelAcceptedBtcBuyOrderCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = cancelAcceptedBtcBuyOrderReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "cancelAcceptedBtcBuyOrder(uint256)"; - const SELECTOR: [u8; 4] = [197u8, 106u8, 69u8, 38u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - cancelAcceptedBtcBuyOrderReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `cancelAcceptedBtcSellOrder(uint256)` and selector `0xdf69b14f`. -```solidity -function cancelAcceptedBtcSellOrder(uint256 id) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct cancelAcceptedBtcSellOrderCall { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - } - ///Container type for the return parameters of the [`cancelAcceptedBtcSellOrder(uint256)`](cancelAcceptedBtcSellOrderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct cancelAcceptedBtcSellOrderReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: cancelAcceptedBtcSellOrderCall) -> Self { - (value.id,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for cancelAcceptedBtcSellOrderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { id: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: cancelAcceptedBtcSellOrderReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for cancelAcceptedBtcSellOrderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl cancelAcceptedBtcSellOrderReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for cancelAcceptedBtcSellOrderCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = cancelAcceptedBtcSellOrderReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "cancelAcceptedBtcSellOrder(uint256)"; - const SELECTOR: [u8; 4] = [223u8, 105u8, 177u8, 79u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - cancelAcceptedBtcSellOrderReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getOpenAcceptedBtcBuyOrders()` and selector `0x6a8cde3a`. -```solidity -function getOpenAcceptedBtcBuyOrders() external view returns (AcceptedBtcBuyOrder[] memory, uint256[] memory); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getOpenAcceptedBtcBuyOrdersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getOpenAcceptedBtcBuyOrders()`](getOpenAcceptedBtcBuyOrdersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getOpenAcceptedBtcBuyOrdersReturn { - #[allow(missing_docs)] - pub _0: alloy::sol_types::private::Vec< - ::RustType, - >, - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getOpenAcceptedBtcBuyOrdersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getOpenAcceptedBtcBuyOrdersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getOpenAcceptedBtcBuyOrdersReturn) -> Self { - (value._0, value._1) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getOpenAcceptedBtcBuyOrdersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0, _1: tuple.1 } - } - } - } - impl getOpenAcceptedBtcBuyOrdersReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - , - > as alloy_sol_types::SolType>::tokenize(&self._1), - ) - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getOpenAcceptedBtcBuyOrdersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = getOpenAcceptedBtcBuyOrdersReturn; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - alloy::sol_types::sol_data::Array>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getOpenAcceptedBtcBuyOrders()"; - const SELECTOR: [u8; 4] = [106u8, 140u8, 222u8, 58u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - getOpenAcceptedBtcBuyOrdersReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getOpenAcceptedBtcSellOrders()` and selector `0x9cc6722e`. -```solidity -function getOpenAcceptedBtcSellOrders() external view returns (AcceptedBtcSellOrder[] memory, uint256[] memory); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getOpenAcceptedBtcSellOrdersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getOpenAcceptedBtcSellOrders()`](getOpenAcceptedBtcSellOrdersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getOpenAcceptedBtcSellOrdersReturn { - #[allow(missing_docs)] - pub _0: alloy::sol_types::private::Vec< - ::RustType, - >, - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getOpenAcceptedBtcSellOrdersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getOpenAcceptedBtcSellOrdersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getOpenAcceptedBtcSellOrdersReturn) -> Self { - (value._0, value._1) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getOpenAcceptedBtcSellOrdersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0, _1: tuple.1 } - } - } - } - impl getOpenAcceptedBtcSellOrdersReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - , - > as alloy_sol_types::SolType>::tokenize(&self._1), - ) - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getOpenAcceptedBtcSellOrdersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = getOpenAcceptedBtcSellOrdersReturn; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - alloy::sol_types::sol_data::Array>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getOpenAcceptedBtcSellOrders()"; - const SELECTOR: [u8; 4] = [156u8, 198u8, 114u8, 46u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - getOpenAcceptedBtcSellOrdersReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getOpenBtcBuyOrders()` and selector `0x1dfe7595`. -```solidity -function getOpenBtcBuyOrders() external view returns (BtcBuyOrder[] memory, uint256[] memory); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getOpenBtcBuyOrdersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getOpenBtcBuyOrders()`](getOpenBtcBuyOrdersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getOpenBtcBuyOrdersReturn { - #[allow(missing_docs)] - pub _0: alloy::sol_types::private::Vec< - ::RustType, - >, - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getOpenBtcBuyOrdersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getOpenBtcBuyOrdersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getOpenBtcBuyOrdersReturn) -> Self { - (value._0, value._1) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getOpenBtcBuyOrdersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0, _1: tuple.1 } - } - } - } - impl getOpenBtcBuyOrdersReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - , - > as alloy_sol_types::SolType>::tokenize(&self._1), - ) - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getOpenBtcBuyOrdersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = getOpenBtcBuyOrdersReturn; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - alloy::sol_types::sol_data::Array>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getOpenBtcBuyOrders()"; - const SELECTOR: [u8; 4] = [29u8, 254u8, 117u8, 149u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - getOpenBtcBuyOrdersReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getOpenBtcSellOrders()` and selector `0x6811a311`. -```solidity -function getOpenBtcSellOrders() external view returns (BtcSellOrder[] memory, uint256[] memory); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getOpenBtcSellOrdersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getOpenBtcSellOrders()`](getOpenBtcSellOrdersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getOpenBtcSellOrdersReturn { - #[allow(missing_docs)] - pub _0: alloy::sol_types::private::Vec< - ::RustType, - >, - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getOpenBtcSellOrdersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getOpenBtcSellOrdersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getOpenBtcSellOrdersReturn) -> Self { - (value._0, value._1) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getOpenBtcSellOrdersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0, _1: tuple.1 } - } - } - } - impl getOpenBtcSellOrdersReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - , - > as alloy_sol_types::SolType>::tokenize(&self._1), - ) - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getOpenBtcSellOrdersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = getOpenBtcSellOrdersReturn; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - alloy::sol_types::sol_data::Array>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getOpenBtcSellOrders()"; - const SELECTOR: [u8; 4] = [104u8, 17u8, 163u8, 17u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - getOpenBtcSellOrdersReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getTrustedForwarder()` and selector `0xce1b815f`. -```solidity -function getTrustedForwarder() external view returns (address forwarder); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getTrustedForwarderCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getTrustedForwarder()`](getTrustedForwarderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getTrustedForwarderReturn { - #[allow(missing_docs)] - pub forwarder: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getTrustedForwarderCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getTrustedForwarderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getTrustedForwarderReturn) -> Self { - (value.forwarder,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getTrustedForwarderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { forwarder: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getTrustedForwarderCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getTrustedForwarder()"; - const SELECTOR: [u8; 4] = [206u8, 27u8, 129u8, 95u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getTrustedForwarderReturn = r.into(); - r.forwarder - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getTrustedForwarderReturn = r.into(); - r.forwarder - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `isTrustedForwarder(address)` and selector `0x572b6c05`. -```solidity -function isTrustedForwarder(address forwarder) external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct isTrustedForwarderCall { - #[allow(missing_docs)] - pub forwarder: alloy::sol_types::private::Address, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`isTrustedForwarder(address)`](isTrustedForwarderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct isTrustedForwarderReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: isTrustedForwarderCall) -> Self { - (value.forwarder,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for isTrustedForwarderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { forwarder: tuple.0 } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: isTrustedForwarderReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for isTrustedForwarderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for isTrustedForwarderCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "isTrustedForwarder(address)"; - const SELECTOR: [u8; 4] = [87u8, 43u8, 108u8, 5u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.forwarder, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: isTrustedForwarderReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: isTrustedForwarderReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `placeBtcBuyOrder(uint256,(bytes),address,uint256)` and selector `0x364f1ec0`. -```solidity -function placeBtcBuyOrder(uint256 amountBtc, BitcoinAddress memory bitcoinAddress, address sellingToken, uint256 saleAmount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct placeBtcBuyOrderCall { - #[allow(missing_docs)] - pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub bitcoinAddress: ::RustType, - #[allow(missing_docs)] - pub sellingToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub saleAmount: alloy::sol_types::private::primitives::aliases::U256, - } - ///Container type for the return parameters of the [`placeBtcBuyOrder(uint256,(bytes),address,uint256)`](placeBtcBuyOrderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct placeBtcBuyOrderReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - BitcoinAddress, - 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, - ::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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: placeBtcBuyOrderCall) -> Self { - ( - value.amountBtc, - value.bitcoinAddress, - value.sellingToken, - value.saleAmount, - ) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for placeBtcBuyOrderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - amountBtc: tuple.0, - bitcoinAddress: tuple.1, - sellingToken: tuple.2, - saleAmount: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: placeBtcBuyOrderReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for placeBtcBuyOrderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl placeBtcBuyOrderReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for placeBtcBuyOrderCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - BitcoinAddress, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = placeBtcBuyOrderReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "placeBtcBuyOrder(uint256,(bytes),address,uint256)"; - const SELECTOR: [u8; 4] = [54u8, 79u8, 30u8, 192u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountBtc), - ::tokenize( - &self.bitcoinAddress, - ), - ::tokenize( - &self.sellingToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.saleAmount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - placeBtcBuyOrderReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `placeBtcSellOrder(uint256,address,uint256)` and selector `0x5b8fe042`. -```solidity -function placeBtcSellOrder(uint256 amountBtc, address buyingToken, uint256 buyAmount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct placeBtcSellOrderCall { - #[allow(missing_docs)] - pub amountBtc: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub buyingToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub buyAmount: alloy::sol_types::private::primitives::aliases::U256, - } - ///Container type for the return parameters of the [`placeBtcSellOrder(uint256,address,uint256)`](placeBtcSellOrderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct placeBtcSellOrderReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - 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::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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: placeBtcSellOrderCall) -> Self { - (value.amountBtc, value.buyingToken, value.buyAmount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for placeBtcSellOrderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - amountBtc: tuple.0, - buyingToken: tuple.1, - buyAmount: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: placeBtcSellOrderReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for placeBtcSellOrderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl placeBtcSellOrderReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for placeBtcSellOrderCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = placeBtcSellOrderReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "placeBtcSellOrder(uint256,address,uint256)"; - const SELECTOR: [u8; 4] = [91u8, 143u8, 224u8, 66u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountBtc), - ::tokenize( - &self.buyingToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.buyAmount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - placeBtcSellOrderReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `proofBtcBuyOrder(uint256,(bytes4,bytes,bytes,bytes4),(bytes,uint256,bytes,bytes32,bytes))` and selector `0xb223d976`. -```solidity -function proofBtcBuyOrder(uint256 id, BitcoinTx.Info memory transaction, BitcoinTx.Proof memory proof) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct proofBtcBuyOrderCall { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub transaction: ::RustType, - #[allow(missing_docs)] - pub proof: ::RustType, - } - ///Container type for the return parameters of the [`proofBtcBuyOrder(uint256,(bytes4,bytes,bytes,bytes4),(bytes,uint256,bytes,bytes32,bytes))`](proofBtcBuyOrderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct proofBtcBuyOrderReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - BitcoinTx::Info, - BitcoinTx::Proof, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ::RustType, - ::RustType, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: proofBtcBuyOrderCall) -> Self { - (value.id, value.transaction, value.proof) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for proofBtcBuyOrderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - id: tuple.0, - transaction: tuple.1, - proof: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: proofBtcBuyOrderReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for proofBtcBuyOrderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl proofBtcBuyOrderReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for proofBtcBuyOrderCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - BitcoinTx::Info, - BitcoinTx::Proof, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = proofBtcBuyOrderReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "proofBtcBuyOrder(uint256,(bytes4,bytes,bytes,bytes4),(bytes,uint256,bytes,bytes32,bytes))"; - const SELECTOR: [u8; 4] = [178u8, 35u8, 217u8, 118u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - ::tokenize( - &self.transaction, - ), - ::tokenize(&self.proof), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - proofBtcBuyOrderReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `proofBtcSellOrder(uint256,(bytes4,bytes,bytes,bytes4),(bytes,uint256,bytes,bytes32,bytes))` and selector `0xfd3fc245`. -```solidity -function proofBtcSellOrder(uint256 id, BitcoinTx.Info memory transaction, BitcoinTx.Proof memory proof) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct proofBtcSellOrderCall { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub transaction: ::RustType, - #[allow(missing_docs)] - pub proof: ::RustType, - } - ///Container type for the return parameters of the [`proofBtcSellOrder(uint256,(bytes4,bytes,bytes,bytes4),(bytes,uint256,bytes,bytes32,bytes))`](proofBtcSellOrderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct proofBtcSellOrderReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - BitcoinTx::Info, - BitcoinTx::Proof, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ::RustType, - ::RustType, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: proofBtcSellOrderCall) -> Self { - (value.id, value.transaction, value.proof) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for proofBtcSellOrderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - id: tuple.0, - transaction: tuple.1, - proof: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: proofBtcSellOrderReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for proofBtcSellOrderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl proofBtcSellOrderReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for proofBtcSellOrderCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - BitcoinTx::Info, - BitcoinTx::Proof, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = proofBtcSellOrderReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "proofBtcSellOrder(uint256,(bytes4,bytes,bytes,bytes4),(bytes,uint256,bytes,bytes32,bytes))"; - const SELECTOR: [u8; 4] = [253u8, 63u8, 194u8, 69u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - ::tokenize( - &self.transaction, - ), - ::tokenize(&self.proof), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - proofBtcSellOrderReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `withdrawBtcBuyOrder(uint256)` and selector `0x506a109d`. -```solidity -function withdrawBtcBuyOrder(uint256 id) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct withdrawBtcBuyOrderCall { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - } - ///Container type for the return parameters of the [`withdrawBtcBuyOrder(uint256)`](withdrawBtcBuyOrderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct withdrawBtcBuyOrderReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: withdrawBtcBuyOrderCall) -> Self { - (value.id,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for withdrawBtcBuyOrderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { id: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: withdrawBtcBuyOrderReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for withdrawBtcBuyOrderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl withdrawBtcBuyOrderReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for withdrawBtcBuyOrderCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = withdrawBtcBuyOrderReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "withdrawBtcBuyOrder(uint256)"; - const SELECTOR: [u8; 4] = [80u8, 106u8, 16u8, 157u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - withdrawBtcBuyOrderReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `withdrawBtcSellOrder(uint256)` and selector `0xa383013b`. -```solidity -function withdrawBtcSellOrder(uint256 id) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct withdrawBtcSellOrderCall { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - } - ///Container type for the return parameters of the [`withdrawBtcSellOrder(uint256)`](withdrawBtcSellOrderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct withdrawBtcSellOrderReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: withdrawBtcSellOrderCall) -> Self { - (value.id,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for withdrawBtcSellOrderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { id: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: withdrawBtcSellOrderReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for withdrawBtcSellOrderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl withdrawBtcSellOrderReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for withdrawBtcSellOrderCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = withdrawBtcSellOrderReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "withdrawBtcSellOrder(uint256)"; - const SELECTOR: [u8; 4] = [163u8, 131u8, 1u8, 59u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - withdrawBtcSellOrderReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`BtcMarketPlace`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum BtcMarketPlaceCalls { - #[allow(missing_docs)] - REQUEST_EXPIRATION_SECONDS(REQUEST_EXPIRATION_SECONDSCall), - #[allow(missing_docs)] - acceptBtcBuyOrder(acceptBtcBuyOrderCall), - #[allow(missing_docs)] - acceptBtcSellOrder(acceptBtcSellOrderCall), - #[allow(missing_docs)] - acceptedBtcBuyOrders(acceptedBtcBuyOrdersCall), - #[allow(missing_docs)] - acceptedBtcSellOrders(acceptedBtcSellOrdersCall), - #[allow(missing_docs)] - btcBuyOrders(btcBuyOrdersCall), - #[allow(missing_docs)] - btcSellOrders(btcSellOrdersCall), - #[allow(missing_docs)] - cancelAcceptedBtcBuyOrder(cancelAcceptedBtcBuyOrderCall), - #[allow(missing_docs)] - cancelAcceptedBtcSellOrder(cancelAcceptedBtcSellOrderCall), - #[allow(missing_docs)] - getOpenAcceptedBtcBuyOrders(getOpenAcceptedBtcBuyOrdersCall), - #[allow(missing_docs)] - getOpenAcceptedBtcSellOrders(getOpenAcceptedBtcSellOrdersCall), - #[allow(missing_docs)] - getOpenBtcBuyOrders(getOpenBtcBuyOrdersCall), - #[allow(missing_docs)] - getOpenBtcSellOrders(getOpenBtcSellOrdersCall), - #[allow(missing_docs)] - getTrustedForwarder(getTrustedForwarderCall), - #[allow(missing_docs)] - isTrustedForwarder(isTrustedForwarderCall), - #[allow(missing_docs)] - placeBtcBuyOrder(placeBtcBuyOrderCall), - #[allow(missing_docs)] - placeBtcSellOrder(placeBtcSellOrderCall), - #[allow(missing_docs)] - proofBtcBuyOrder(proofBtcBuyOrderCall), - #[allow(missing_docs)] - proofBtcSellOrder(proofBtcSellOrderCall), - #[allow(missing_docs)] - withdrawBtcBuyOrder(withdrawBtcBuyOrderCall), - #[allow(missing_docs)] - withdrawBtcSellOrder(withdrawBtcSellOrderCall), - } - #[automatically_derived] - impl BtcMarketPlaceCalls { - /// 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]] = &[ - [17u8, 193u8, 55u8, 170u8], - [29u8, 254u8, 117u8, 149u8], - [33u8, 14u8, 193u8, 129u8], - [54u8, 79u8, 30u8, 192u8], - [58u8, 243u8, 252u8, 126u8], - [65u8, 69u8, 100u8, 10u8], - [80u8, 106u8, 16u8, 157u8], - [87u8, 43u8, 108u8, 5u8], - [91u8, 143u8, 224u8, 66u8], - [104u8, 17u8, 163u8, 17u8], - [106u8, 140u8, 222u8, 58u8], - [156u8, 198u8, 114u8, 46u8], - [163u8, 131u8, 1u8, 59u8], - [178u8, 35u8, 217u8, 118u8], - [189u8, 42u8, 126u8, 62u8], - [197u8, 106u8, 69u8, 38u8], - [206u8, 27u8, 129u8, 95u8], - [209u8, 146u8, 15u8, 240u8], - [223u8, 105u8, 177u8, 79u8], - [236u8, 202u8, 44u8, 54u8], - [253u8, 63u8, 194u8, 69u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for BtcMarketPlaceCalls { - const NAME: &'static str = "BtcMarketPlaceCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 21usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::REQUEST_EXPIRATION_SECONDS(_) => { - ::SELECTOR - } - Self::acceptBtcBuyOrder(_) => { - ::SELECTOR - } - Self::acceptBtcSellOrder(_) => { - ::SELECTOR - } - Self::acceptedBtcBuyOrders(_) => { - ::SELECTOR - } - Self::acceptedBtcSellOrders(_) => { - ::SELECTOR - } - Self::btcBuyOrders(_) => { - ::SELECTOR - } - Self::btcSellOrders(_) => { - ::SELECTOR - } - Self::cancelAcceptedBtcBuyOrder(_) => { - ::SELECTOR - } - Self::cancelAcceptedBtcSellOrder(_) => { - ::SELECTOR - } - Self::getOpenAcceptedBtcBuyOrders(_) => { - ::SELECTOR - } - Self::getOpenAcceptedBtcSellOrders(_) => { - ::SELECTOR - } - Self::getOpenBtcBuyOrders(_) => { - ::SELECTOR - } - Self::getOpenBtcSellOrders(_) => { - ::SELECTOR - } - Self::getTrustedForwarder(_) => { - ::SELECTOR - } - Self::isTrustedForwarder(_) => { - ::SELECTOR - } - Self::placeBtcBuyOrder(_) => { - ::SELECTOR - } - Self::placeBtcSellOrder(_) => { - ::SELECTOR - } - Self::proofBtcBuyOrder(_) => { - ::SELECTOR - } - Self::proofBtcSellOrder(_) => { - ::SELECTOR - } - Self::withdrawBtcBuyOrder(_) => { - ::SELECTOR - } - Self::withdrawBtcSellOrder(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn acceptBtcBuyOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BtcMarketPlaceCalls::acceptBtcBuyOrder) - } - acceptBtcBuyOrder - }, - { - fn getOpenBtcBuyOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BtcMarketPlaceCalls::getOpenBtcBuyOrders) - } - getOpenBtcBuyOrders - }, - { - fn acceptBtcSellOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BtcMarketPlaceCalls::acceptBtcSellOrder) - } - acceptBtcSellOrder - }, - { - fn placeBtcBuyOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BtcMarketPlaceCalls::placeBtcBuyOrder) - } - placeBtcBuyOrder - }, - { - fn btcBuyOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BtcMarketPlaceCalls::btcBuyOrders) - } - btcBuyOrders - }, - { - fn acceptedBtcSellOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BtcMarketPlaceCalls::acceptedBtcSellOrders) - } - acceptedBtcSellOrders - }, - { - fn withdrawBtcBuyOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BtcMarketPlaceCalls::withdrawBtcBuyOrder) - } - withdrawBtcBuyOrder - }, - { - fn isTrustedForwarder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BtcMarketPlaceCalls::isTrustedForwarder) - } - isTrustedForwarder - }, - { - fn placeBtcSellOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BtcMarketPlaceCalls::placeBtcSellOrder) - } - placeBtcSellOrder - }, - { - fn getOpenBtcSellOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BtcMarketPlaceCalls::getOpenBtcSellOrders) - } - getOpenBtcSellOrders - }, - { - fn getOpenAcceptedBtcBuyOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BtcMarketPlaceCalls::getOpenAcceptedBtcBuyOrders) - } - getOpenAcceptedBtcBuyOrders - }, - { - fn getOpenAcceptedBtcSellOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BtcMarketPlaceCalls::getOpenAcceptedBtcSellOrders) - } - getOpenAcceptedBtcSellOrders - }, - { - fn withdrawBtcSellOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BtcMarketPlaceCalls::withdrawBtcSellOrder) - } - withdrawBtcSellOrder - }, - { - fn proofBtcBuyOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BtcMarketPlaceCalls::proofBtcBuyOrder) - } - proofBtcBuyOrder - }, - { - fn acceptedBtcBuyOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BtcMarketPlaceCalls::acceptedBtcBuyOrders) - } - acceptedBtcBuyOrders - }, - { - fn cancelAcceptedBtcBuyOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BtcMarketPlaceCalls::cancelAcceptedBtcBuyOrder) - } - cancelAcceptedBtcBuyOrder - }, - { - fn getTrustedForwarder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BtcMarketPlaceCalls::getTrustedForwarder) - } - getTrustedForwarder - }, - { - fn REQUEST_EXPIRATION_SECONDS( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BtcMarketPlaceCalls::REQUEST_EXPIRATION_SECONDS) - } - REQUEST_EXPIRATION_SECONDS - }, - { - fn cancelAcceptedBtcSellOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BtcMarketPlaceCalls::cancelAcceptedBtcSellOrder) - } - cancelAcceptedBtcSellOrder - }, - { - fn btcSellOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BtcMarketPlaceCalls::btcSellOrders) - } - btcSellOrders - }, - { - fn proofBtcSellOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BtcMarketPlaceCalls::proofBtcSellOrder) - } - proofBtcSellOrder - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn acceptBtcBuyOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BtcMarketPlaceCalls::acceptBtcBuyOrder) - } - acceptBtcBuyOrder - }, - { - fn getOpenBtcBuyOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BtcMarketPlaceCalls::getOpenBtcBuyOrders) - } - getOpenBtcBuyOrders - }, - { - fn acceptBtcSellOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BtcMarketPlaceCalls::acceptBtcSellOrder) - } - acceptBtcSellOrder - }, - { - fn placeBtcBuyOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BtcMarketPlaceCalls::placeBtcBuyOrder) - } - placeBtcBuyOrder - }, - { - fn btcBuyOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BtcMarketPlaceCalls::btcBuyOrders) - } - btcBuyOrders - }, - { - fn acceptedBtcSellOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BtcMarketPlaceCalls::acceptedBtcSellOrders) - } - acceptedBtcSellOrders - }, - { - fn withdrawBtcBuyOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BtcMarketPlaceCalls::withdrawBtcBuyOrder) - } - withdrawBtcBuyOrder - }, - { - fn isTrustedForwarder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BtcMarketPlaceCalls::isTrustedForwarder) - } - isTrustedForwarder - }, - { - fn placeBtcSellOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BtcMarketPlaceCalls::placeBtcSellOrder) - } - placeBtcSellOrder - }, - { - fn getOpenBtcSellOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BtcMarketPlaceCalls::getOpenBtcSellOrders) - } - getOpenBtcSellOrders - }, - { - fn getOpenAcceptedBtcBuyOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BtcMarketPlaceCalls::getOpenAcceptedBtcBuyOrders) - } - getOpenAcceptedBtcBuyOrders - }, - { - fn getOpenAcceptedBtcSellOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BtcMarketPlaceCalls::getOpenAcceptedBtcSellOrders) - } - getOpenAcceptedBtcSellOrders - }, - { - fn withdrawBtcSellOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BtcMarketPlaceCalls::withdrawBtcSellOrder) - } - withdrawBtcSellOrder - }, - { - fn proofBtcBuyOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BtcMarketPlaceCalls::proofBtcBuyOrder) - } - proofBtcBuyOrder - }, - { - fn acceptedBtcBuyOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BtcMarketPlaceCalls::acceptedBtcBuyOrders) - } - acceptedBtcBuyOrders - }, - { - fn cancelAcceptedBtcBuyOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BtcMarketPlaceCalls::cancelAcceptedBtcBuyOrder) - } - cancelAcceptedBtcBuyOrder - }, - { - fn getTrustedForwarder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BtcMarketPlaceCalls::getTrustedForwarder) - } - getTrustedForwarder - }, - { - fn REQUEST_EXPIRATION_SECONDS( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BtcMarketPlaceCalls::REQUEST_EXPIRATION_SECONDS) - } - REQUEST_EXPIRATION_SECONDS - }, - { - fn cancelAcceptedBtcSellOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BtcMarketPlaceCalls::cancelAcceptedBtcSellOrder) - } - cancelAcceptedBtcSellOrder - }, - { - fn btcSellOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BtcMarketPlaceCalls::btcSellOrders) - } - btcSellOrders - }, - { - fn proofBtcSellOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BtcMarketPlaceCalls::proofBtcSellOrder) - } - proofBtcSellOrder - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::REQUEST_EXPIRATION_SECONDS(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::acceptBtcBuyOrder(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::acceptBtcSellOrder(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::acceptedBtcBuyOrders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::acceptedBtcSellOrders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::btcBuyOrders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::btcSellOrders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::cancelAcceptedBtcBuyOrder(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::cancelAcceptedBtcSellOrder(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getOpenAcceptedBtcBuyOrders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getOpenAcceptedBtcSellOrders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getOpenBtcBuyOrders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getOpenBtcSellOrders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getTrustedForwarder(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::isTrustedForwarder(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::placeBtcBuyOrder(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::placeBtcSellOrder(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::proofBtcBuyOrder(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::proofBtcSellOrder(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::withdrawBtcBuyOrder(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::withdrawBtcSellOrder(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::REQUEST_EXPIRATION_SECONDS(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::acceptBtcBuyOrder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::acceptBtcSellOrder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::acceptedBtcBuyOrders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::acceptedBtcSellOrders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::btcBuyOrders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::btcSellOrders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::cancelAcceptedBtcBuyOrder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::cancelAcceptedBtcSellOrder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getOpenAcceptedBtcBuyOrders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getOpenAcceptedBtcSellOrders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getOpenBtcBuyOrders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getOpenBtcSellOrders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getTrustedForwarder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::isTrustedForwarder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::placeBtcBuyOrder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::placeBtcSellOrder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::proofBtcBuyOrder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::proofBtcSellOrder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::withdrawBtcBuyOrder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::withdrawBtcSellOrder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`BtcMarketPlace`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum BtcMarketPlaceEvents { - #[allow(missing_docs)] - acceptBtcBuyOrderEvent(acceptBtcBuyOrderEvent), - #[allow(missing_docs)] - acceptBtcSellOrderEvent(acceptBtcSellOrderEvent), - #[allow(missing_docs)] - cancelAcceptedBtcBuyOrderEvent(cancelAcceptedBtcBuyOrderEvent), - #[allow(missing_docs)] - cancelAcceptedBtcSellOrderEvent(cancelAcceptedBtcSellOrderEvent), - #[allow(missing_docs)] - placeBtcBuyOrderEvent(placeBtcBuyOrderEvent), - #[allow(missing_docs)] - placeBtcSellOrderEvent(placeBtcSellOrderEvent), - #[allow(missing_docs)] - proofBtcBuyOrderEvent(proofBtcBuyOrderEvent), - #[allow(missing_docs)] - proofBtcSellOrderEvent(proofBtcSellOrderEvent), - #[allow(missing_docs)] - withdrawBtcBuyOrderEvent(withdrawBtcBuyOrderEvent), - #[allow(missing_docs)] - withdrawBtcSellOrderEvent(withdrawBtcSellOrderEvent), - } - #[automatically_derived] - impl BtcMarketPlaceEvents { - /// 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]] = &[ - [ - 60u8, 212u8, 117u8, 176u8, 146u8, 232u8, 179u8, 121u8, 246u8, 186u8, - 13u8, 158u8, 14u8, 12u8, 143u8, 48u8, 112u8, 94u8, 115u8, 50u8, 29u8, - 197u8, 201u8, 248u8, 12u8, 228u8, 173u8, 56u8, 219u8, 123u8, 225u8, 170u8, - ], - [ - 62u8, 94u8, 163u8, 88u8, 233u8, 235u8, 76u8, 223u8, 68u8, 205u8, 199u8, - 121u8, 56u8, 173u8, 232u8, 7u8, 75u8, 18u8, 64u8, 166u8, 216u8, 192u8, - 253u8, 19u8, 114u8, 134u8, 113u8, 184u8, 46u8, 128u8, 10u8, 214u8, - ], - [ - 101u8, 62u8, 13u8, 129u8, 242u8, 201u8, 155u8, 235u8, 163u8, 89u8, 223u8, - 177u8, 123u8, 73u8, 154u8, 92u8, 255u8, 43u8, 233u8, 217u8, 80u8, 81u8, - 72u8, 82u8, 34u8, 77u8, 248u8, 192u8, 151u8, 194u8, 25u8, 33u8, - ], - [ - 120u8, 245u8, 31u8, 98u8, 247u8, 207u8, 19u8, 129u8, 198u8, 115u8, 194u8, - 126u8, 174u8, 24u8, 125u8, 214u8, 197u8, 136u8, 220u8, 102u8, 36u8, - 206u8, 89u8, 105u8, 125u8, 187u8, 62u8, 29u8, 124u8, 27u8, 188u8, 223u8, - ], - [ - 152u8, 199u8, 198u8, 128u8, 64u8, 61u8, 71u8, 64u8, 61u8, 234u8, 74u8, - 87u8, 13u8, 14u8, 108u8, 87u8, 22u8, 83u8, 140u8, 73u8, 66u8, 14u8, - 244u8, 113u8, 206u8, 196u8, 40u8, 245u8, 165u8, 133u8, 44u8, 6u8, - ], - [ - 180u8, 201u8, 141u8, 226u8, 16u8, 105u8, 107u8, 60u8, 242u8, 30u8, 153u8, - 51u8, 92u8, 30u8, 227u8, 160u8, 174u8, 52u8, 162u8, 103u8, 19u8, 65u8, - 42u8, 74u8, 221u8, 232u8, 175u8, 89u8, 97u8, 118u8, 243u8, 126u8, - ], - [ - 195u8, 64u8, 231u8, 172u8, 72u8, 220u8, 128u8, 238u8, 121u8, 63u8, 198u8, - 38u8, 105u8, 96u8, 189u8, 95u8, 27u8, 210u8, 27u8, 233u8, 28u8, 138u8, - 149u8, 226u8, 24u8, 23u8, 129u8, 19u8, 247u8, 158u8, 23u8, 180u8, - ], - [ - 195u8, 154u8, 26u8, 93u8, 220u8, 14u8, 133u8, 201u8, 85u8, 254u8, 46u8, - 26u8, 190u8, 180u8, 60u8, 148u8, 206u8, 24u8, 50u8, 46u8, 117u8, 187u8, - 61u8, 68u8, 232u8, 15u8, 117u8, 159u8, 249u8, 208u8, 52u8, 185u8, - ], - [ - 207u8, 86u8, 16u8, 97u8, 219u8, 120u8, 247u8, 188u8, 81u8, 141u8, 55u8, - 254u8, 134u8, 113u8, 133u8, 20u8, 198u8, 64u8, 204u8, 197u8, 195u8, - 241u8, 41u8, 56u8, 40u8, 185u8, 85u8, 230u8, 143u8, 25u8, 245u8, 251u8, - ], - [ - 255u8, 28u8, 226u8, 16u8, 222u8, 252u8, 211u8, 186u8, 26u8, 223u8, 118u8, - 201u8, 65u8, 154u8, 7u8, 88u8, 250u8, 96u8, 253u8, 62u8, 179u8, 140u8, - 123u8, 217u8, 65u8, 143u8, 96u8, 181u8, 117u8, 183u8, 110u8, 36u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for BtcMarketPlaceEvents { - const NAME: &'static str = "BtcMarketPlaceEvents"; - const COUNT: usize = 10usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::acceptBtcBuyOrderEvent) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::acceptBtcSellOrderEvent) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::cancelAcceptedBtcBuyOrderEvent) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::cancelAcceptedBtcSellOrderEvent) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::placeBtcBuyOrderEvent) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::placeBtcSellOrderEvent) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::proofBtcBuyOrderEvent) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::proofBtcSellOrderEvent) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::withdrawBtcBuyOrderEvent) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::withdrawBtcSellOrderEvent) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 BtcMarketPlaceEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::acceptBtcBuyOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::acceptBtcSellOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::cancelAcceptedBtcBuyOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::cancelAcceptedBtcSellOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::placeBtcBuyOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::placeBtcSellOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::proofBtcBuyOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::proofBtcSellOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::withdrawBtcBuyOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::withdrawBtcSellOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::acceptBtcBuyOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::acceptBtcSellOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::cancelAcceptedBtcBuyOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::cancelAcceptedBtcSellOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::placeBtcBuyOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::placeBtcSellOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::proofBtcBuyOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::proofBtcSellOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::withdrawBtcBuyOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::withdrawBtcSellOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`BtcMarketPlace`](self) contract instance. - -See the [wrapper's documentation](`BtcMarketPlaceInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> BtcMarketPlaceInstance { - BtcMarketPlaceInstance::::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: alloy_contract::private::Network, - >( - provider: P, - _relay: alloy::sol_types::private::Address, - erc2771Forwarder: alloy::sol_types::private::Address, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - BtcMarketPlaceInstance::::deploy(provider, _relay, erc2771Forwarder) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - _relay: alloy::sol_types::private::Address, - erc2771Forwarder: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - BtcMarketPlaceInstance::< - P, - N, - >::deploy_builder(provider, _relay, erc2771Forwarder) - } - /**A [`BtcMarketPlace`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`BtcMarketPlace`](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 BtcMarketPlaceInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for BtcMarketPlaceInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("BtcMarketPlaceInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BtcMarketPlaceInstance { - /**Creates a new wrapper around an on-chain [`BtcMarketPlace`](self) contract instance. - -See the [wrapper's documentation](`BtcMarketPlaceInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - _relay: alloy::sol_types::private::Address, - erc2771Forwarder: alloy::sol_types::private::Address, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder(provider, _relay, erc2771Forwarder); - 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, - _relay: alloy::sol_types::private::Address, - erc2771Forwarder: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { - _relay, - erc2771Forwarder, - }, - )[..], - ] - .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 BtcMarketPlaceInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> BtcMarketPlaceInstance { - BtcMarketPlaceInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BtcMarketPlaceInstance { - /// 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( - &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 [`REQUEST_EXPIRATION_SECONDS`] function. - pub fn REQUEST_EXPIRATION_SECONDS( - &self, - ) -> alloy_contract::SolCallBuilder<&P, REQUEST_EXPIRATION_SECONDSCall, N> { - self.call_builder(&REQUEST_EXPIRATION_SECONDSCall) - } - ///Creates a new call builder for the [`acceptBtcBuyOrder`] function. - pub fn acceptBtcBuyOrder( - &self, - id: alloy::sol_types::private::primitives::aliases::U256, - amountBtc: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, acceptBtcBuyOrderCall, N> { - self.call_builder( - &acceptBtcBuyOrderCall { - id, - amountBtc, - }, - ) - } - ///Creates a new call builder for the [`acceptBtcSellOrder`] function. - pub fn acceptBtcSellOrder( - &self, - id: alloy::sol_types::private::primitives::aliases::U256, - bitcoinAddress: ::RustType, - amountBtc: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, acceptBtcSellOrderCall, N> { - self.call_builder( - &acceptBtcSellOrderCall { - id, - bitcoinAddress, - amountBtc, - }, - ) - } - ///Creates a new call builder for the [`acceptedBtcBuyOrders`] function. - pub fn acceptedBtcBuyOrders( - &self, - _0: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, acceptedBtcBuyOrdersCall, N> { - self.call_builder(&acceptedBtcBuyOrdersCall(_0)) - } - ///Creates a new call builder for the [`acceptedBtcSellOrders`] function. - pub fn acceptedBtcSellOrders( - &self, - _0: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, acceptedBtcSellOrdersCall, N> { - self.call_builder(&acceptedBtcSellOrdersCall(_0)) - } - ///Creates a new call builder for the [`btcBuyOrders`] function. - pub fn btcBuyOrders( - &self, - _0: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, btcBuyOrdersCall, N> { - self.call_builder(&btcBuyOrdersCall(_0)) - } - ///Creates a new call builder for the [`btcSellOrders`] function. - pub fn btcSellOrders( - &self, - _0: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, btcSellOrdersCall, N> { - self.call_builder(&btcSellOrdersCall(_0)) - } - ///Creates a new call builder for the [`cancelAcceptedBtcBuyOrder`] function. - pub fn cancelAcceptedBtcBuyOrder( - &self, - id: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, cancelAcceptedBtcBuyOrderCall, N> { - self.call_builder( - &cancelAcceptedBtcBuyOrderCall { - id, - }, - ) - } - ///Creates a new call builder for the [`cancelAcceptedBtcSellOrder`] function. - pub fn cancelAcceptedBtcSellOrder( - &self, - id: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, cancelAcceptedBtcSellOrderCall, N> { - self.call_builder( - &cancelAcceptedBtcSellOrderCall { - id, - }, - ) - } - ///Creates a new call builder for the [`getOpenAcceptedBtcBuyOrders`] function. - pub fn getOpenAcceptedBtcBuyOrders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, getOpenAcceptedBtcBuyOrdersCall, N> { - self.call_builder(&getOpenAcceptedBtcBuyOrdersCall) - } - ///Creates a new call builder for the [`getOpenAcceptedBtcSellOrders`] function. - pub fn getOpenAcceptedBtcSellOrders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, getOpenAcceptedBtcSellOrdersCall, N> { - self.call_builder(&getOpenAcceptedBtcSellOrdersCall) - } - ///Creates a new call builder for the [`getOpenBtcBuyOrders`] function. - pub fn getOpenBtcBuyOrders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, getOpenBtcBuyOrdersCall, N> { - self.call_builder(&getOpenBtcBuyOrdersCall) - } - ///Creates a new call builder for the [`getOpenBtcSellOrders`] function. - pub fn getOpenBtcSellOrders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, getOpenBtcSellOrdersCall, N> { - self.call_builder(&getOpenBtcSellOrdersCall) - } - ///Creates a new call builder for the [`getTrustedForwarder`] function. - pub fn getTrustedForwarder( - &self, - ) -> alloy_contract::SolCallBuilder<&P, getTrustedForwarderCall, N> { - self.call_builder(&getTrustedForwarderCall) - } - ///Creates a new call builder for the [`isTrustedForwarder`] function. - pub fn isTrustedForwarder( - &self, - forwarder: alloy::sol_types::private::Address, - ) -> alloy_contract::SolCallBuilder<&P, isTrustedForwarderCall, N> { - self.call_builder( - &isTrustedForwarderCall { - forwarder, - }, - ) - } - ///Creates a new call builder for the [`placeBtcBuyOrder`] function. - pub fn placeBtcBuyOrder( - &self, - amountBtc: alloy::sol_types::private::primitives::aliases::U256, - bitcoinAddress: ::RustType, - sellingToken: alloy::sol_types::private::Address, - saleAmount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, placeBtcBuyOrderCall, N> { - self.call_builder( - &placeBtcBuyOrderCall { - amountBtc, - bitcoinAddress, - sellingToken, - saleAmount, - }, - ) - } - ///Creates a new call builder for the [`placeBtcSellOrder`] function. - pub fn placeBtcSellOrder( - &self, - amountBtc: alloy::sol_types::private::primitives::aliases::U256, - buyingToken: alloy::sol_types::private::Address, - buyAmount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, placeBtcSellOrderCall, N> { - self.call_builder( - &placeBtcSellOrderCall { - amountBtc, - buyingToken, - buyAmount, - }, - ) - } - ///Creates a new call builder for the [`proofBtcBuyOrder`] function. - pub fn proofBtcBuyOrder( - &self, - id: alloy::sol_types::private::primitives::aliases::U256, - transaction: ::RustType, - proof: ::RustType, - ) -> alloy_contract::SolCallBuilder<&P, proofBtcBuyOrderCall, N> { - self.call_builder( - &proofBtcBuyOrderCall { - id, - transaction, - proof, - }, - ) - } - ///Creates a new call builder for the [`proofBtcSellOrder`] function. - pub fn proofBtcSellOrder( - &self, - id: alloy::sol_types::private::primitives::aliases::U256, - transaction: ::RustType, - proof: ::RustType, - ) -> alloy_contract::SolCallBuilder<&P, proofBtcSellOrderCall, N> { - self.call_builder( - &proofBtcSellOrderCall { - id, - transaction, - proof, - }, - ) - } - ///Creates a new call builder for the [`withdrawBtcBuyOrder`] function. - pub fn withdrawBtcBuyOrder( - &self, - id: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, withdrawBtcBuyOrderCall, N> { - self.call_builder(&withdrawBtcBuyOrderCall { id }) - } - ///Creates a new call builder for the [`withdrawBtcSellOrder`] function. - pub fn withdrawBtcSellOrder( - &self, - id: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, withdrawBtcSellOrderCall, N> { - self.call_builder(&withdrawBtcSellOrderCall { id }) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BtcMarketPlaceInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`acceptBtcBuyOrderEvent`] event. - pub fn acceptBtcBuyOrderEvent_filter( - &self, - ) -> alloy_contract::Event<&P, acceptBtcBuyOrderEvent, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`acceptBtcSellOrderEvent`] event. - pub fn acceptBtcSellOrderEvent_filter( - &self, - ) -> alloy_contract::Event<&P, acceptBtcSellOrderEvent, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`cancelAcceptedBtcBuyOrderEvent`] event. - pub fn cancelAcceptedBtcBuyOrderEvent_filter( - &self, - ) -> alloy_contract::Event<&P, cancelAcceptedBtcBuyOrderEvent, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`cancelAcceptedBtcSellOrderEvent`] event. - pub fn cancelAcceptedBtcSellOrderEvent_filter( - &self, - ) -> alloy_contract::Event<&P, cancelAcceptedBtcSellOrderEvent, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`placeBtcBuyOrderEvent`] event. - pub fn placeBtcBuyOrderEvent_filter( - &self, - ) -> alloy_contract::Event<&P, placeBtcBuyOrderEvent, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`placeBtcSellOrderEvent`] event. - pub fn placeBtcSellOrderEvent_filter( - &self, - ) -> alloy_contract::Event<&P, placeBtcSellOrderEvent, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`proofBtcBuyOrderEvent`] event. - pub fn proofBtcBuyOrderEvent_filter( - &self, - ) -> alloy_contract::Event<&P, proofBtcBuyOrderEvent, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`proofBtcSellOrderEvent`] event. - pub fn proofBtcSellOrderEvent_filter( - &self, - ) -> alloy_contract::Event<&P, proofBtcSellOrderEvent, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`withdrawBtcBuyOrderEvent`] event. - pub fn withdrawBtcBuyOrderEvent_filter( - &self, - ) -> alloy_contract::Event<&P, withdrawBtcBuyOrderEvent, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`withdrawBtcSellOrderEvent`] event. - pub fn withdrawBtcSellOrderEvent_filter( - &self, - ) -> alloy_contract::Event<&P, withdrawBtcSellOrderEvent, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/btc_utils.rs b/crates/bindings/src/btc_utils.rs deleted file mode 100644 index 58c2c2447..000000000 --- a/crates/bindings/src/btc_utils.rs +++ /dev/null @@ -1,1127 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface BTCUtils { - function DIFF1_TARGET() external view returns (uint256); - function ERR_BAD_ARG() external view returns (uint256); - function RETARGET_PERIOD() external view returns (uint256); - function RETARGET_PERIOD_BLOCKS() external view returns (uint256); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "DIFF1_TARGET", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "ERR_BAD_ARG", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "RETARGET_PERIOD", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "RETARGET_PERIOD_BLOCKS", - "inputs": [], - "outputs": [ - { - "name": "", - "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 BTCUtils { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x60f5610033600b8282823980515f1a607314602757634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe73000000000000000000000000000000000000000030146080604052600436106050575f3560e01c8063056e04ec1460545780638cc7156914606f5780638db69e60146077578063d4258ca714609d575b5f5ffd5b605d6212750081565b60405190815260200160405180910390f35b605d6107e081565b605d7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff81565b605d7bffff00000000000000000000000000000000000000000000000000008156fea26469706673582212204afe711b3e801231c37f83227290cabaa52e9f6dd8632511d4665f0d533ba5d964736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"`\xF5a\x003`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`'WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R`\x046\x10`PW_5`\xE0\x1C\x80c\x05n\x04\xEC\x14`TW\x80c\x8C\xC7\x15i\x14`oW\x80c\x8D\xB6\x9E`\x14`wW\x80c\xD4%\x8C\xA7\x14`\x9DW[__\xFD[`]b\x12u\0\x81V[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[`]a\x07\xE0\x81V[`]\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81V[`]{\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\x81V\xFE\xA2dipfsX\"\x12 J\xFEq\x1B>\x80\x121\xC3\x7F\x83\"r\x90\xCA\xBA\xA5.\x9Fm\xD8c%\x11\xD4f_\rS;\xA5\xD9dsolcC\0\x08\x1C\x003", - ); - /// The runtime bytecode of the contract, as deployed on the network. - /// - /// ```text - ///0x73000000000000000000000000000000000000000030146080604052600436106050575f3560e01c8063056e04ec1460545780638cc7156914606f5780638db69e60146077578063d4258ca714609d575b5f5ffd5b605d6212750081565b60405190815260200160405180910390f35b605d6107e081565b605d7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff81565b605d7bffff00000000000000000000000000000000000000000000000000008156fea26469706673582212204afe711b3e801231c37f83227290cabaa52e9f6dd8632511d4665f0d533ba5d964736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R`\x046\x10`PW_5`\xE0\x1C\x80c\x05n\x04\xEC\x14`TW\x80c\x8C\xC7\x15i\x14`oW\x80c\x8D\xB6\x9E`\x14`wW\x80c\xD4%\x8C\xA7\x14`\x9DW[__\xFD[`]b\x12u\0\x81V[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[`]a\x07\xE0\x81V[`]\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81V[`]{\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\x81V\xFE\xA2dipfsX\"\x12 J\xFEq\x1B>\x80\x121\xC3\x7F\x83\"r\x90\xCA\xBA\xA5.\x9Fm\xD8c%\x11\xD4f_\rS;\xA5\xD9dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `DIFF1_TARGET()` and selector `0xd4258ca7`. -```solidity -function DIFF1_TARGET() external view returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct DIFF1_TARGETCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`DIFF1_TARGET()`](DIFF1_TARGETCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct DIFF1_TARGETReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: DIFF1_TARGETCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for DIFF1_TARGETCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: DIFF1_TARGETReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for DIFF1_TARGETReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for DIFF1_TARGETCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "DIFF1_TARGET()"; - const SELECTOR: [u8; 4] = [212u8, 37u8, 140u8, 167u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: DIFF1_TARGETReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: DIFF1_TARGETReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `ERR_BAD_ARG()` and selector `0x8db69e60`. -```solidity -function ERR_BAD_ARG() external view returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct ERR_BAD_ARGCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`ERR_BAD_ARG()`](ERR_BAD_ARGCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct ERR_BAD_ARGReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: ERR_BAD_ARGCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for ERR_BAD_ARGCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: ERR_BAD_ARGReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for ERR_BAD_ARGReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for ERR_BAD_ARGCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "ERR_BAD_ARG()"; - const SELECTOR: [u8; 4] = [141u8, 182u8, 158u8, 96u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: ERR_BAD_ARGReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: ERR_BAD_ARGReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `RETARGET_PERIOD()` and selector `0x056e04ec`. -```solidity -function RETARGET_PERIOD() external view returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct RETARGET_PERIODCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`RETARGET_PERIOD()`](RETARGET_PERIODCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct RETARGET_PERIODReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: RETARGET_PERIODCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for RETARGET_PERIODCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: RETARGET_PERIODReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for RETARGET_PERIODReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for RETARGET_PERIODCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "RETARGET_PERIOD()"; - const SELECTOR: [u8; 4] = [5u8, 110u8, 4u8, 236u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: RETARGET_PERIODReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: RETARGET_PERIODReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `RETARGET_PERIOD_BLOCKS()` and selector `0x8cc71569`. -```solidity -function RETARGET_PERIOD_BLOCKS() external view returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct RETARGET_PERIOD_BLOCKSCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`RETARGET_PERIOD_BLOCKS()`](RETARGET_PERIOD_BLOCKSCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct RETARGET_PERIOD_BLOCKSReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: RETARGET_PERIOD_BLOCKSCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for RETARGET_PERIOD_BLOCKSCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: RETARGET_PERIOD_BLOCKSReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for RETARGET_PERIOD_BLOCKSReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for RETARGET_PERIOD_BLOCKSCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "RETARGET_PERIOD_BLOCKS()"; - const SELECTOR: [u8; 4] = [140u8, 199u8, 21u8, 105u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: RETARGET_PERIOD_BLOCKSReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: RETARGET_PERIOD_BLOCKSReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`BTCUtils`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum BTCUtilsCalls { - #[allow(missing_docs)] - DIFF1_TARGET(DIFF1_TARGETCall), - #[allow(missing_docs)] - ERR_BAD_ARG(ERR_BAD_ARGCall), - #[allow(missing_docs)] - RETARGET_PERIOD(RETARGET_PERIODCall), - #[allow(missing_docs)] - RETARGET_PERIOD_BLOCKS(RETARGET_PERIOD_BLOCKSCall), - } - #[automatically_derived] - impl BTCUtilsCalls { - /// 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, 110u8, 4u8, 236u8], - [140u8, 199u8, 21u8, 105u8], - [141u8, 182u8, 158u8, 96u8], - [212u8, 37u8, 140u8, 167u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for BTCUtilsCalls { - const NAME: &'static str = "BTCUtilsCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 4usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::DIFF1_TARGET(_) => { - ::SELECTOR - } - Self::ERR_BAD_ARG(_) => { - ::SELECTOR - } - Self::RETARGET_PERIOD(_) => { - ::SELECTOR - } - Self::RETARGET_PERIOD_BLOCKS(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn RETARGET_PERIOD( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BTCUtilsCalls::RETARGET_PERIOD) - } - RETARGET_PERIOD - }, - { - fn RETARGET_PERIOD_BLOCKS( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BTCUtilsCalls::RETARGET_PERIOD_BLOCKS) - } - RETARGET_PERIOD_BLOCKS - }, - { - fn ERR_BAD_ARG( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BTCUtilsCalls::ERR_BAD_ARG) - } - ERR_BAD_ARG - }, - { - fn DIFF1_TARGET( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(BTCUtilsCalls::DIFF1_TARGET) - } - DIFF1_TARGET - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn RETARGET_PERIOD( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BTCUtilsCalls::RETARGET_PERIOD) - } - RETARGET_PERIOD - }, - { - fn RETARGET_PERIOD_BLOCKS( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BTCUtilsCalls::RETARGET_PERIOD_BLOCKS) - } - RETARGET_PERIOD_BLOCKS - }, - { - fn ERR_BAD_ARG( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BTCUtilsCalls::ERR_BAD_ARG) - } - ERR_BAD_ARG - }, - { - fn DIFF1_TARGET( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(BTCUtilsCalls::DIFF1_TARGET) - } - DIFF1_TARGET - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::DIFF1_TARGET(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::ERR_BAD_ARG(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::RETARGET_PERIOD(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::RETARGET_PERIOD_BLOCKS(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::DIFF1_TARGET(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::ERR_BAD_ARG(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::RETARGET_PERIOD(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::RETARGET_PERIOD_BLOCKS(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`BTCUtils`](self) contract instance. - -See the [wrapper's documentation](`BTCUtilsInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> BTCUtilsInstance { - BTCUtilsInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - BTCUtilsInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - BTCUtilsInstance::::deploy_builder(provider) - } - /**A [`BTCUtils`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`BTCUtils`](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 BTCUtilsInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for BTCUtilsInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("BTCUtilsInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BTCUtilsInstance { - /**Creates a new wrapper around an on-chain [`BTCUtils`](self) contract instance. - -See the [wrapper's documentation](`BTCUtilsInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 BTCUtilsInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> BTCUtilsInstance { - BTCUtilsInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BTCUtilsInstance { - /// 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( - &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 [`DIFF1_TARGET`] function. - pub fn DIFF1_TARGET( - &self, - ) -> alloy_contract::SolCallBuilder<&P, DIFF1_TARGETCall, N> { - self.call_builder(&DIFF1_TARGETCall) - } - ///Creates a new call builder for the [`ERR_BAD_ARG`] function. - pub fn ERR_BAD_ARG( - &self, - ) -> alloy_contract::SolCallBuilder<&P, ERR_BAD_ARGCall, N> { - self.call_builder(&ERR_BAD_ARGCall) - } - ///Creates a new call builder for the [`RETARGET_PERIOD`] function. - pub fn RETARGET_PERIOD( - &self, - ) -> alloy_contract::SolCallBuilder<&P, RETARGET_PERIODCall, N> { - self.call_builder(&RETARGET_PERIODCall) - } - ///Creates a new call builder for the [`RETARGET_PERIOD_BLOCKS`] function. - pub fn RETARGET_PERIOD_BLOCKS( - &self, - ) -> alloy_contract::SolCallBuilder<&P, RETARGET_PERIOD_BLOCKSCall, N> { - self.call_builder(&RETARGET_PERIOD_BLOCKSCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BTCUtilsInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/bytes_lib.rs b/crates/bindings/src/bytes_lib.rs deleted file mode 100644 index c19571143..000000000 --- a/crates/bindings/src/bytes_lib.rs +++ /dev/null @@ -1,218 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface BytesLib {} -``` - -...which was generated by the following JSON ABI: -```json -[] -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod BytesLib { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212209a4a0cd11b50491dcbc1b2a3e1999d38d54febad1422a52d9aadf9a58b393f7764736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"`U`2`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`&WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \x9AJ\x0C\xD1\x1BPI\x1D\xCB\xC1\xB2\xA3\xE1\x99\x9D8\xD5O\xEB\xAD\x14\"\xA5-\x9A\xAD\xF9\xA5\x8B9?wdsolcC\0\x08\x1C\x003", - ); - /// The runtime bytecode of the contract, as deployed on the network. - /// - /// ```text - ///0x730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212209a4a0cd11b50491dcbc1b2a3e1999d38d54febad1422a52d9aadf9a58b393f7764736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \x9AJ\x0C\xD1\x1BPI\x1D\xCB\xC1\xB2\xA3\xE1\x99\x9D8\xD5O\xEB\xAD\x14\"\xA5-\x9A\xAD\xF9\xA5\x8B9?wdsolcC\0\x08\x1C\x003", - ); - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`BytesLib`](self) contract instance. - -See the [wrapper's documentation](`BytesLibInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> BytesLibInstance { - BytesLibInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - BytesLibInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - BytesLibInstance::::deploy_builder(provider) - } - /**A [`BytesLib`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`BytesLib`](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 BytesLibInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for BytesLibInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("BytesLibInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BytesLibInstance { - /**Creates a new wrapper around an on-chain [`BytesLib`](self) contract instance. - -See the [wrapper's documentation](`BytesLibInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 BytesLibInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> BytesLibInstance { - BytesLibInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BytesLibInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BytesLibInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/constants.rs b/crates/bindings/src/constants.rs deleted file mode 100644 index 38e7eadfb..000000000 --- a/crates/bindings/src/constants.rs +++ /dev/null @@ -1,218 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface Constants {} -``` - -...which was generated by the following JSON ABI: -```json -[] -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod Constants { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220b69d9c4cc91b81f95f9c689cc275984dcc763f96c9734bc4af4883ea2035ca5464736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"`U`2`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`&WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \xB6\x9D\x9CL\xC9\x1B\x81\xF9_\x9Ch\x9C\xC2u\x98M\xCCv?\x96\xC9sK\xC4\xAFH\x83\xEA 5\xCATdsolcC\0\x08\x1C\x003", - ); - /// The runtime bytecode of the contract, as deployed on the network. - /// - /// ```text - ///0x730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220b69d9c4cc91b81f95f9c689cc275984dcc763f96c9734bc4af4883ea2035ca5464736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \xB6\x9D\x9CL\xC9\x1B\x81\xF9_\x9Ch\x9C\xC2u\x98M\xCCv?\x96\xC9sK\xC4\xAFH\x83\xEA 5\xCATdsolcC\0\x08\x1C\x003", - ); - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`Constants`](self) contract instance. - -See the [wrapper's documentation](`ConstantsInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> ConstantsInstance { - ConstantsInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - ConstantsInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - ConstantsInstance::::deploy_builder(provider) - } - /**A [`Constants`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`Constants`](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 ConstantsInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for ConstantsInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("ConstantsInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ConstantsInstance { - /**Creates a new wrapper around an on-chain [`Constants`](self) contract instance. - -See the [wrapper's documentation](`ConstantsInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 ConstantsInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> ConstantsInstance { - ConstantsInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ConstantsInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ConstantsInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/context.rs b/crates/bindings/src/context.rs deleted file mode 100644 index 093632258..000000000 --- a/crates/bindings/src/context.rs +++ /dev/null @@ -1,215 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface Context {} -``` - -...which was generated by the following JSON ABI: -```json -[] -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod Context { - use super::*; - use alloy::sol_types as 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"", - ); - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`Context`](self) contract instance. - -See the [wrapper's documentation](`ContextInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >(address: alloy_sol_types::private::Address, provider: P) -> ContextInstance { - ContextInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - ContextInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - ContextInstance::::deploy_builder(provider) - } - /**A [`Context`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`Context`](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 ContextInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for ContextInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("ContextInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ContextInstance { - /**Creates a new wrapper around an on-chain [`Context`](self) contract instance. - -See the [wrapper's documentation](`ContextInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 ContextInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> ContextInstance { - ContextInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ContextInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ContextInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/dummy_avalon_pool_implementation.rs b/crates/bindings/src/dummy_avalon_pool_implementation.rs deleted file mode 100644 index bf1215b71..000000000 --- a/crates/bindings/src/dummy_avalon_pool_implementation.rs +++ /dev/null @@ -1,940 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface DummyAvalonPoolImplementation { - constructor(address _avalonToken, bool _doSupply); - - function supply(address, uint256 amount, address onBehalfOf, uint16) external; - function withdraw(address, uint256, address) external pure returns (uint256); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "_avalonToken", - "type": "address", - "internalType": "contract ArbitaryErc20" - }, - { - "name": "_doSupply", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "supply", - "inputs": [ - { - "name": "", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "onBehalfOf", - "type": "address", - "internalType": "address" - }, - { - "name": "", - "type": "uint16", - "internalType": "uint16" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "withdraw", - "inputs": [ - { - "name": "", - "type": "address", - "internalType": "address" - }, - { - "name": "", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "", - "type": "address", - "internalType": "address" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "pure" - } -] -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod DummyAvalonPoolImplementation { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x6080604052348015600e575f5ffd5b506040516102fe3803806102fe833981016040819052602b916066565b5f80546001600160a01b039093166001600160a01b0319921515600160a01b02929092166001600160a81b03199093169290921717905560aa565b5f5f604083850312156076575f5ffd5b82516001600160a01b0381168114608b575f5ffd5b60208401519092508015158114609f575f5ffd5b809150509250929050565b610247806100b75f395ff3fe608060405234801561000f575f5ffd5b5060043610610034575f3560e01c8063617ba0371461003857806369328dec1461004d575b5f5ffd5b61004b610046366004610160565b610075565b005b61006361005b3660046101b2565b5f9392505050565b60405190815260200160405180910390f35b5f5474010000000000000000000000000000000000000000900460ff1615610132575f546040517fa9059cbb00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8481166004830152602482018690529091169063a9059cbb906044016020604051808303815f875af115801561010c573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061013091906101eb565b505b50505050565b803573ffffffffffffffffffffffffffffffffffffffff8116811461015b575f5ffd5b919050565b5f5f5f5f60808587031215610173575f5ffd5b61017c85610138565b93506020850135925061019160408601610138565b9150606085013561ffff811681146101a7575f5ffd5b939692955090935050565b5f5f5f606084860312156101c4575f5ffd5b6101cd84610138565b9250602084013591506101e260408501610138565b90509250925092565b5f602082840312156101fb575f5ffd5b8151801515811461020a575f5ffd5b939250505056fea264697066735822122053c4cc04f9e8e633eb3b781a2eef09f6394d8f7dcfcfe674f20a92a8b04ce71d64736f6c634300081c0033 - /// ``` - #[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`@Qa\x02\xFE8\x03\x80a\x02\xFE\x839\x81\x01`@\x81\x90R`+\x91`fV[_\x80T`\x01`\x01`\xA0\x1B\x03\x90\x93\x16`\x01`\x01`\xA0\x1B\x03\x19\x92\x15\x15`\x01`\xA0\x1B\x02\x92\x90\x92\x16`\x01`\x01`\xA8\x1B\x03\x19\x90\x93\x16\x92\x90\x92\x17\x17\x90U`\xAAV[__`@\x83\x85\x03\x12\x15`vW__\xFD[\x82Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14`\x8BW__\xFD[` \x84\x01Q\x90\x92P\x80\x15\x15\x81\x14`\x9FW__\xFD[\x80\x91PP\x92P\x92\x90PV[a\x02G\x80a\0\xB7_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x004W_5`\xE0\x1C\x80ca{\xA07\x14a\08W\x80ci2\x8D\xEC\x14a\0MW[__\xFD[a\0Ka\0F6`\x04a\x01`V[a\0uV[\0[a\0ca\0[6`\x04a\x01\xB2V[_\x93\x92PPPV[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[_Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x012W_T`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R\x90\x91\x16\x90c\xA9\x05\x9C\xBB\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\x0CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x010\x91\x90a\x01\xEBV[P[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\x01[W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x01sW__\xFD[a\x01|\x85a\x018V[\x93P` \x85\x015\x92Pa\x01\x91`@\x86\x01a\x018V[\x91P``\x85\x015a\xFF\xFF\x81\x16\x81\x14a\x01\xA7W__\xFD[\x93\x96\x92\x95P\x90\x93PPV[___``\x84\x86\x03\x12\x15a\x01\xC4W__\xFD[a\x01\xCD\x84a\x018V[\x92P` \x84\x015\x91Pa\x01\xE2`@\x85\x01a\x018V[\x90P\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a\x01\xFBW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x02\nW__\xFD[\x93\x92PPPV\xFE\xA2dipfsX\"\x12 S\xC4\xCC\x04\xF9\xE8\xE63\xEB;x\x1A.\xEF\t\xF69M\x8F}\xCF\xCF\xE6t\xF2\n\x92\xA8\xB0L\xE7\x1DdsolcC\0\x08\x1C\x003", - ); - /// The runtime bytecode of the contract, as deployed on the network. - /// - /// ```text - ///0x608060405234801561000f575f5ffd5b5060043610610034575f3560e01c8063617ba0371461003857806369328dec1461004d575b5f5ffd5b61004b610046366004610160565b610075565b005b61006361005b3660046101b2565b5f9392505050565b60405190815260200160405180910390f35b5f5474010000000000000000000000000000000000000000900460ff1615610132575f546040517fa9059cbb00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8481166004830152602482018690529091169063a9059cbb906044016020604051808303815f875af115801561010c573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061013091906101eb565b505b50505050565b803573ffffffffffffffffffffffffffffffffffffffff8116811461015b575f5ffd5b919050565b5f5f5f5f60808587031215610173575f5ffd5b61017c85610138565b93506020850135925061019160408601610138565b9150606085013561ffff811681146101a7575f5ffd5b939692955090935050565b5f5f5f606084860312156101c4575f5ffd5b6101cd84610138565b9250602084013591506101e260408501610138565b90509250925092565b5f602082840312156101fb575f5ffd5b8151801515811461020a575f5ffd5b939250505056fea264697066735822122053c4cc04f9e8e633eb3b781a2eef09f6394d8f7dcfcfe674f20a92a8b04ce71d64736f6c634300081c0033 - /// ``` - #[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\x80ca{\xA07\x14a\08W\x80ci2\x8D\xEC\x14a\0MW[__\xFD[a\0Ka\0F6`\x04a\x01`V[a\0uV[\0[a\0ca\0[6`\x04a\x01\xB2V[_\x93\x92PPPV[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[_Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x012W_T`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R\x90\x91\x16\x90c\xA9\x05\x9C\xBB\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\x0CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x010\x91\x90a\x01\xEBV[P[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\x01[W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x01sW__\xFD[a\x01|\x85a\x018V[\x93P` \x85\x015\x92Pa\x01\x91`@\x86\x01a\x018V[\x91P``\x85\x015a\xFF\xFF\x81\x16\x81\x14a\x01\xA7W__\xFD[\x93\x96\x92\x95P\x90\x93PPV[___``\x84\x86\x03\x12\x15a\x01\xC4W__\xFD[a\x01\xCD\x84a\x018V[\x92P` \x84\x015\x91Pa\x01\xE2`@\x85\x01a\x018V[\x90P\x92P\x92P\x92V[_` \x82\x84\x03\x12\x15a\x01\xFBW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x02\nW__\xFD[\x93\x92PPPV\xFE\xA2dipfsX\"\x12 S\xC4\xCC\x04\xF9\xE8\xE63\xEB;x\x1A.\xEF\t\xF69M\x8F}\xCF\xCF\xE6t\xF2\n\x92\xA8\xB0L\xE7\x1DdsolcC\0\x08\x1C\x003", - ); - /**Constructor`. -```solidity -constructor(address _avalonToken, bool _doSupply); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct constructorCall { - #[allow(missing_docs)] - pub _avalonToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub _doSupply: bool, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value._avalonToken, value._doSupply) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - _avalonToken: tuple.0, - _doSupply: 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> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._avalonToken, - ), - ::tokenize( - &self._doSupply, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `supply(address,uint256,address,uint16)` and selector `0x617ba037`. -```solidity -function supply(address, uint256 amount, address onBehalfOf, uint16) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct supplyCall { - #[allow(missing_docs)] - pub _0: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub onBehalfOf: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub _3: u16, - } - ///Container type for the return parameters of the [`supply(address,uint256,address,uint16)`](supplyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct supplyReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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<16>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::primitives::aliases::U256, - alloy::sol_types::private::Address, - u16, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: supplyCall) -> Self { - (value._0, value.amount, value.onBehalfOf, value._3) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for supplyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - _0: tuple.0, - amount: tuple.1, - onBehalfOf: tuple.2, - _3: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: supplyReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for supplyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl supplyReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for supplyCall { - 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<16>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = supplyReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "supply(address,uint256,address,uint16)"; - const SELECTOR: [u8; 4] = [97u8, 123u8, 160u8, 55u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._0, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ::tokenize( - &self.onBehalfOf, - ), - as alloy_sol_types::SolType>::tokenize(&self._3), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - supplyReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `withdraw(address,uint256,address)` and selector `0x69328dec`. -```solidity -function withdraw(address, uint256, address) external pure returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct withdrawCall { - #[allow(missing_docs)] - pub _0: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub _1: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub _2: alloy::sol_types::private::Address, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`withdraw(address,uint256,address)`](withdrawCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct withdrawReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: withdrawCall) -> Self { - (value._0, value._1, value._2) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for withdrawCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - _0: tuple.0, - _1: tuple.1, - _2: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: withdrawReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for withdrawReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[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::Address, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "withdraw(address,uint256,address)"; - const SELECTOR: [u8; 4] = [105u8, 50u8, 141u8, 236u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._0, - ), - as alloy_sol_types::SolType>::tokenize(&self._1), - ::tokenize( - &self._2, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: withdrawReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: withdrawReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`DummyAvalonPoolImplementation`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum DummyAvalonPoolImplementationCalls { - #[allow(missing_docs)] - supply(supplyCall), - #[allow(missing_docs)] - withdraw(withdrawCall), - } - #[automatically_derived] - impl DummyAvalonPoolImplementationCalls { - /// 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]] = &[ - [97u8, 123u8, 160u8, 55u8], - [105u8, 50u8, 141u8, 236u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for DummyAvalonPoolImplementationCalls { - const NAME: &'static str = "DummyAvalonPoolImplementationCalls"; - const MIN_DATA_LENGTH: usize = 96usize; - const COUNT: usize = 2usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::supply(_) => ::SELECTOR, - Self::withdraw(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn supply( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyAvalonPoolImplementationCalls::supply) - } - supply - }, - { - fn withdraw( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyAvalonPoolImplementationCalls::withdraw) - } - withdraw - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn supply( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyAvalonPoolImplementationCalls::supply) - } - supply - }, - { - fn withdraw( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyAvalonPoolImplementationCalls::withdraw) - } - withdraw - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::supply(inner) => { - ::abi_encoded_size(inner) - } - Self::withdraw(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::supply(inner) => { - ::abi_encode_raw(inner, out) - } - Self::withdraw(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`DummyAvalonPoolImplementation`](self) contract instance. - -See the [wrapper's documentation](`DummyAvalonPoolImplementationInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> DummyAvalonPoolImplementationInstance { - DummyAvalonPoolImplementationInstance::::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: alloy_contract::private::Network, - >( - provider: P, - _avalonToken: alloy::sol_types::private::Address, - _doSupply: bool, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - DummyAvalonPoolImplementationInstance::< - P, - N, - >::deploy(provider, _avalonToken, _doSupply) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - _avalonToken: alloy::sol_types::private::Address, - _doSupply: bool, - ) -> alloy_contract::RawCallBuilder { - DummyAvalonPoolImplementationInstance::< - P, - N, - >::deploy_builder(provider, _avalonToken, _doSupply) - } - /**A [`DummyAvalonPoolImplementation`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`DummyAvalonPoolImplementation`](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 DummyAvalonPoolImplementationInstance< - P, - N = alloy_contract::private::Ethereum, - > { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for DummyAvalonPoolImplementationInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("DummyAvalonPoolImplementationInstance") - .field(&self.address) - .finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummyAvalonPoolImplementationInstance { - /**Creates a new wrapper around an on-chain [`DummyAvalonPoolImplementation`](self) contract instance. - -See the [wrapper's documentation](`DummyAvalonPoolImplementationInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - _avalonToken: alloy::sol_types::private::Address, - _doSupply: bool, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder(provider, _avalonToken, _doSupply); - 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, - _avalonToken: alloy::sol_types::private::Address, - _doSupply: bool, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { - _avalonToken, - _doSupply, - }, - )[..], - ] - .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 DummyAvalonPoolImplementationInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider( - self, - ) -> DummyAvalonPoolImplementationInstance { - DummyAvalonPoolImplementationInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummyAvalonPoolImplementationInstance { - /// 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( - &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 [`supply`] function. - pub fn supply( - &self, - _0: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - onBehalfOf: alloy::sol_types::private::Address, - _3: u16, - ) -> alloy_contract::SolCallBuilder<&P, supplyCall, N> { - self.call_builder( - &supplyCall { - _0, - amount, - onBehalfOf, - _3, - }, - ) - } - ///Creates a new call builder for the [`withdraw`] function. - pub fn withdraw( - &self, - _0: alloy::sol_types::private::Address, - _1: alloy::sol_types::private::primitives::aliases::U256, - _2: alloy::sol_types::private::Address, - ) -> alloy_contract::SolCallBuilder<&P, withdrawCall, N> { - self.call_builder(&withdrawCall { _0, _1, _2 }) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummyAvalonPoolImplementationInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/dummy_bedrock_vault_implementation.rs b/crates/bindings/src/dummy_bedrock_vault_implementation.rs deleted file mode 100644 index 4cadfb410..000000000 --- a/crates/bindings/src/dummy_bedrock_vault_implementation.rs +++ /dev/null @@ -1,1060 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface DummyBedrockVaultImplementation { - constructor(address _uniBtcToken, bool _doMint); - - function mint(address, uint256 amount) external; - function redeem(address token, uint256 amount) external; - function uniBTC() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "_uniBtcToken", - "type": "address", - "internalType": "contract ArbitaryErc20" - }, - { - "name": "_doMint", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "mint", - "inputs": [ - { - "name": "", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "redeem", - "inputs": [ - { - "name": "token", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "uniBTC", - "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 DummyBedrockVaultImplementation { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x6080604052348015600e575f5ffd5b506040516102a83803806102a8833981016040819052602b916066565b5f80546001600160a01b039093166001600160a01b0319921515600160a01b02929092166001600160a81b03199093169290921717905560aa565b5f5f604083850312156076575f5ffd5b82516001600160a01b0381168114608b575f5ffd5b60208401519092508015158114609f575f5ffd5b809150509250929050565b6101f1806100b75f395ff3fe608060405234801561000f575f5ffd5b506004361061003f575f3560e01c80631e9a69501461004357806340c10f191461005757806359f3d39b1461006a575b5f5ffd5b610055610051366004610153565b5050565b005b610055610065366004610153565b610095565b5f546040805173ffffffffffffffffffffffffffffffffffffffff9092168252519081900360200190f35b5f5474010000000000000000000000000000000000000000900460ff1615610051575f546040517fa9059cbb0000000000000000000000000000000000000000000000000000000081523360048201526024810183905273ffffffffffffffffffffffffffffffffffffffff9091169063a9059cbb906044016020604051808303815f875af115801561012a573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061014e9190610195565b505050565b5f5f60408385031215610164575f5ffd5b823573ffffffffffffffffffffffffffffffffffffffff81168114610187575f5ffd5b946020939093013593505050565b5f602082840312156101a5575f5ffd5b815180151581146101b4575f5ffd5b939250505056fea26469706673582212201b70e9eaf7912da9c6465df0c44462b2a7ac1d899bd092ca54040522be6f9a5264736f6c634300081c0033 - /// ``` - #[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`@Qa\x02\xA88\x03\x80a\x02\xA8\x839\x81\x01`@\x81\x90R`+\x91`fV[_\x80T`\x01`\x01`\xA0\x1B\x03\x90\x93\x16`\x01`\x01`\xA0\x1B\x03\x19\x92\x15\x15`\x01`\xA0\x1B\x02\x92\x90\x92\x16`\x01`\x01`\xA8\x1B\x03\x19\x90\x93\x16\x92\x90\x92\x17\x17\x90U`\xAAV[__`@\x83\x85\x03\x12\x15`vW__\xFD[\x82Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14`\x8BW__\xFD[` \x84\x01Q\x90\x92P\x80\x15\x15\x81\x14`\x9FW__\xFD[\x80\x91PP\x92P\x92\x90PV[a\x01\xF1\x80a\0\xB7_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0?W_5`\xE0\x1C\x80c\x1E\x9AiP\x14a\0CW\x80c@\xC1\x0F\x19\x14a\0WW\x80cY\xF3\xD3\x9B\x14a\0jW[__\xFD[a\0Ua\0Q6`\x04a\x01SV[PPV[\0[a\0Ua\0e6`\x04a\x01SV[a\0\x95V[_T`@\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[_Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\0QW_T`@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\x81R3`\x04\x82\x01R`$\x81\x01\x83\x90Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x90c\xA9\x05\x9C\xBB\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01*W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01N\x91\x90a\x01\x95V[PPPV[__`@\x83\x85\x03\x12\x15a\x01dW__\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\x01\x87W__\xFD[\x94` \x93\x90\x93\x015\x93PPPV[_` \x82\x84\x03\x12\x15a\x01\xA5W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x01\xB4W__\xFD[\x93\x92PPPV\xFE\xA2dipfsX\"\x12 \x1Bp\xE9\xEA\xF7\x91-\xA9\xC6F]\xF0\xC4Db\xB2\xA7\xAC\x1D\x89\x9B\xD0\x92\xCAT\x04\x05\"\xBEo\x9ARdsolcC\0\x08\x1C\x003", - ); - /// The runtime bytecode of the contract, as deployed on the network. - /// - /// ```text - ///0x608060405234801561000f575f5ffd5b506004361061003f575f3560e01c80631e9a69501461004357806340c10f191461005757806359f3d39b1461006a575b5f5ffd5b610055610051366004610153565b5050565b005b610055610065366004610153565b610095565b5f546040805173ffffffffffffffffffffffffffffffffffffffff9092168252519081900360200190f35b5f5474010000000000000000000000000000000000000000900460ff1615610051575f546040517fa9059cbb0000000000000000000000000000000000000000000000000000000081523360048201526024810183905273ffffffffffffffffffffffffffffffffffffffff9091169063a9059cbb906044016020604051808303815f875af115801561012a573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061014e9190610195565b505050565b5f5f60408385031215610164575f5ffd5b823573ffffffffffffffffffffffffffffffffffffffff81168114610187575f5ffd5b946020939093013593505050565b5f602082840312156101a5575f5ffd5b815180151581146101b4575f5ffd5b939250505056fea26469706673582212201b70e9eaf7912da9c6465df0c44462b2a7ac1d899bd092ca54040522be6f9a5264736f6c634300081c0033 - /// ``` - #[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\x1E\x9AiP\x14a\0CW\x80c@\xC1\x0F\x19\x14a\0WW\x80cY\xF3\xD3\x9B\x14a\0jW[__\xFD[a\0Ua\0Q6`\x04a\x01SV[PPV[\0[a\0Ua\0e6`\x04a\x01SV[a\0\x95V[_T`@\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[_Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\0QW_T`@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\x81R3`\x04\x82\x01R`$\x81\x01\x83\x90Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x90c\xA9\x05\x9C\xBB\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01*W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01N\x91\x90a\x01\x95V[PPPV[__`@\x83\x85\x03\x12\x15a\x01dW__\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\x01\x87W__\xFD[\x94` \x93\x90\x93\x015\x93PPPV[_` \x82\x84\x03\x12\x15a\x01\xA5W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x01\xB4W__\xFD[\x93\x92PPPV\xFE\xA2dipfsX\"\x12 \x1Bp\xE9\xEA\xF7\x91-\xA9\xC6F]\xF0\xC4Db\xB2\xA7\xAC\x1D\x89\x9B\xD0\x92\xCAT\x04\x05\"\xBEo\x9ARdsolcC\0\x08\x1C\x003", - ); - /**Constructor`. -```solidity -constructor(address _uniBtcToken, bool _doMint); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct constructorCall { - #[allow(missing_docs)] - pub _uniBtcToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub _doMint: bool, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value._uniBtcToken, value._doMint) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - _uniBtcToken: tuple.0, - _doMint: 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> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._uniBtcToken, - ), - ::tokenize( - &self._doMint, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `mint(address,uint256)` and selector `0x40c10f19`. -```solidity -function mint(address, uint256 amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct mintCall { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: mintCall) -> Self { - (value._0, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for mintCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - _0: tuple.0, - amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: mintReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for mintReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl mintReturn { - fn _tokenize( - &self, - ) -> ::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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = mintReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "mint(address,uint256)"; - const SELECTOR: [u8; 4] = [64u8, 193u8, 15u8, 25u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._0, - ), - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `redeem(address,uint256)` and selector `0x1e9a6950`. -```solidity -function redeem(address token, uint256 amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct redeemCall { - #[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 [`redeem(address,uint256)`](redeemCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct redeemReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: redeemCall) -> Self { - (value.token, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for redeemCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - token: tuple.0, - amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: redeemReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for redeemReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl redeemReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for redeemCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = redeemReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "redeem(address,uint256)"; - const SELECTOR: [u8; 4] = [30u8, 154u8, 105u8, 80u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.token, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - redeemReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `uniBTC()` and selector `0x59f3d39b`. -```solidity -function uniBTC() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct uniBTCCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`uniBTC()`](uniBTCCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct uniBTCReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: uniBTCCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for uniBTCCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: uniBTCReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for uniBTCReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for uniBTCCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "uniBTC()"; - const SELECTOR: [u8; 4] = [89u8, 243u8, 211u8, 155u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: uniBTCReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: uniBTCReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`DummyBedrockVaultImplementation`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum DummyBedrockVaultImplementationCalls { - #[allow(missing_docs)] - mint(mintCall), - #[allow(missing_docs)] - redeem(redeemCall), - #[allow(missing_docs)] - uniBTC(uniBTCCall), - } - #[automatically_derived] - impl DummyBedrockVaultImplementationCalls { - /// 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]] = &[ - [30u8, 154u8, 105u8, 80u8], - [64u8, 193u8, 15u8, 25u8], - [89u8, 243u8, 211u8, 155u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for DummyBedrockVaultImplementationCalls { - const NAME: &'static str = "DummyBedrockVaultImplementationCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 3usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::mint(_) => ::SELECTOR, - Self::redeem(_) => ::SELECTOR, - Self::uniBTC(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn redeem( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyBedrockVaultImplementationCalls::redeem) - } - redeem - }, - { - fn mint( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyBedrockVaultImplementationCalls::mint) - } - mint - }, - { - fn uniBTC( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyBedrockVaultImplementationCalls::uniBTC) - } - uniBTC - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn redeem( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyBedrockVaultImplementationCalls::redeem) - } - redeem - }, - { - fn mint( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyBedrockVaultImplementationCalls::mint) - } - mint - }, - { - fn uniBTC( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyBedrockVaultImplementationCalls::uniBTC) - } - uniBTC - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::mint(inner) => { - ::abi_encoded_size(inner) - } - Self::redeem(inner) => { - ::abi_encoded_size(inner) - } - Self::uniBTC(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::mint(inner) => { - ::abi_encode_raw(inner, out) - } - Self::redeem(inner) => { - ::abi_encode_raw(inner, out) - } - Self::uniBTC(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`DummyBedrockVaultImplementation`](self) contract instance. - -See the [wrapper's documentation](`DummyBedrockVaultImplementationInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> DummyBedrockVaultImplementationInstance { - DummyBedrockVaultImplementationInstance::::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: alloy_contract::private::Network, - >( - provider: P, - _uniBtcToken: alloy::sol_types::private::Address, - _doMint: bool, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - DummyBedrockVaultImplementationInstance::< - P, - N, - >::deploy(provider, _uniBtcToken, _doMint) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - _uniBtcToken: alloy::sol_types::private::Address, - _doMint: bool, - ) -> alloy_contract::RawCallBuilder { - DummyBedrockVaultImplementationInstance::< - P, - N, - >::deploy_builder(provider, _uniBtcToken, _doMint) - } - /**A [`DummyBedrockVaultImplementation`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`DummyBedrockVaultImplementation`](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 DummyBedrockVaultImplementationInstance< - P, - N = alloy_contract::private::Ethereum, - > { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for DummyBedrockVaultImplementationInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("DummyBedrockVaultImplementationInstance") - .field(&self.address) - .finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummyBedrockVaultImplementationInstance { - /**Creates a new wrapper around an on-chain [`DummyBedrockVaultImplementation`](self) contract instance. - -See the [wrapper's documentation](`DummyBedrockVaultImplementationInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - _uniBtcToken: alloy::sol_types::private::Address, - _doMint: bool, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder(provider, _uniBtcToken, _doMint); - 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, - _uniBtcToken: alloy::sol_types::private::Address, - _doMint: bool, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { - _uniBtcToken, - _doMint, - }, - )[..], - ] - .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 DummyBedrockVaultImplementationInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider( - self, - ) -> DummyBedrockVaultImplementationInstance { - DummyBedrockVaultImplementationInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummyBedrockVaultImplementationInstance { - /// 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( - &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 [`mint`] function. - pub fn mint( - &self, - _0: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> { - self.call_builder(&mintCall { _0, amount }) - } - ///Creates a new call builder for the [`redeem`] function. - pub fn redeem( - &self, - token: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, redeemCall, N> { - self.call_builder(&redeemCall { token, amount }) - } - ///Creates a new call builder for the [`uniBTC`] function. - pub fn uniBTC(&self) -> alloy_contract::SolCallBuilder<&P, uniBTCCall, N> { - self.call_builder(&uniBTCCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummyBedrockVaultImplementationInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/dummy_ionic_pool.rs b/crates/bindings/src/dummy_ionic_pool.rs deleted file mode 100644 index a67371f0c..000000000 --- a/crates/bindings/src/dummy_ionic_pool.rs +++ /dev/null @@ -1,842 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface DummyIonicPool { - constructor(bool _doEnterMarkets); - - function enterMarkets(address[] memory cTokens) external view returns (uint256[] memory); - function exitMarket(address) external pure returns (uint256); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "_doEnterMarkets", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "enterMarkets", - "inputs": [ - { - "name": "cTokens", - "type": "address[]", - "internalType": "address[]" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "exitMarket", - "inputs": [ - { - "name": "", - "type": "address", - "internalType": "address" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "pure" - } -] -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod DummyIonicPool { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x6080604052348015600e575f5ffd5b50604051610392380380610392833981016040819052602b91603f565b5f805460ff19169115159190911790556063565b5f60208284031215604e575f5ffd5b81518015158114605c575f5ffd5b9392505050565b610322806100705f395ff3fe608060405234801561000f575f5ffd5b5060043610610034575f3560e01c8063c299823814610038578063ede4edd014610061575b5f5ffd5b61004b610046366004610174565b610082565b604051610058919061025d565b60405180910390f35b61007461006f36600461029f565b505f90565b604051908152602001610058565b5f5460609060ff16156100d957815167ffffffffffffffff8111156100a9576100a961011f565b6040519080825280602002602001820160405280156100d2578160200160208202803683370190505b5092915050565b6040805160018082528183019092525f91602080830190803683370190505090506001815f8151811061010e5761010e6102bf565b602090810291909101015292915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b803573ffffffffffffffffffffffffffffffffffffffff8116811461016f575f5ffd5b919050565b5f60208284031215610184575f5ffd5b813567ffffffffffffffff81111561019a575f5ffd5b8201601f810184136101aa575f5ffd5b803567ffffffffffffffff8111156101c4576101c461011f565b8060051b6040517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0603f830116810181811067ffffffffffffffff8211171561020f5761020f61011f565b60405291825260208184018101929081018784111561022c575f5ffd5b6020850194505b83851015610252576102448561014c565b815260209485019401610233565b509695505050505050565b602080825282518282018190525f918401906040840190835b81811015610294578351835260209384019390920191600101610276565b509095945050505050565b5f602082840312156102af575f5ffd5b6102b88261014c565b9392505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffdfea26469706673582212203c556799d4a9c9701cb4512c4ec0ccdbf14634228f9b490e15920fdeea36b7a864736f6c634300081c0033 - /// ``` - #[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`@Qa\x03\x928\x03\x80a\x03\x92\x839\x81\x01`@\x81\x90R`+\x91`?V[_\x80T`\xFF\x19\x16\x91\x15\x15\x91\x90\x91\x17\x90U`cV[_` \x82\x84\x03\x12\x15`NW__\xFD[\x81Q\x80\x15\x15\x81\x14`\\W__\xFD[\x93\x92PPPV[a\x03\"\x80a\0p_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x004W_5`\xE0\x1C\x80c\xC2\x99\x828\x14a\08W\x80c\xED\xE4\xED\xD0\x14a\0aW[__\xFD[a\0Ka\0F6`\x04a\x01tV[a\0\x82V[`@Qa\0X\x91\x90a\x02]V[`@Q\x80\x91\x03\x90\xF3[a\0ta\0o6`\x04a\x02\x9FV[P_\x90V[`@Q\x90\x81R` \x01a\0XV[_T``\x90`\xFF\x16\x15a\0\xD9W\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\0\xA9Wa\0\xA9a\x01\x1FV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\0\xD2W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x92\x91PPV[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91` \x80\x83\x01\x90\x806\x837\x01\x90PP\x90P`\x01\x81_\x81Q\x81\x10a\x01\x0EWa\x01\x0Ea\x02\xBFV[` \x90\x81\x02\x91\x90\x91\x01\x01R\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`A`\x04R`$_\xFD[\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\x01oW__\xFD[\x91\x90PV[_` \x82\x84\x03\x12\x15a\x01\x84W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x01\x9AW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x01\xAAW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x01\xC4Wa\x01\xC4a\x01\x1FV[\x80`\x05\x1B`@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`?\x83\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x02\x0FWa\x02\x0Fa\x01\x1FV[`@R\x91\x82R` \x81\x84\x01\x81\x01\x92\x90\x81\x01\x87\x84\x11\x15a\x02,W__\xFD[` \x85\x01\x94P[\x83\x85\x10\x15a\x02RWa\x02D\x85a\x01LV[\x81R` \x94\x85\x01\x94\x01a\x023V[P\x96\x95PPPPPPV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x02\x94W\x83Q\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x02vV[P\x90\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x02\xAFW__\xFD[a\x02\xB8\x82a\x01LV[\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\xFE\xA2dipfsX\"\x12 = (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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value._doEnterMarkets,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _doEnterMarkets: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolConstructor for constructorCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Bool,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._doEnterMarkets, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `enterMarkets(address[])` and selector `0xc2998238`. -```solidity -function enterMarkets(address[] memory cTokens) external view returns (uint256[] memory); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct enterMarketsCall { - #[allow(missing_docs)] - pub cTokens: alloy::sol_types::private::Vec, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`enterMarkets(address[])`](enterMarketsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct enterMarketsReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: enterMarketsCall) -> Self { - (value.cTokens,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for enterMarketsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { cTokens: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - #[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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: enterMarketsReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for enterMarketsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for enterMarketsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "enterMarkets(address[])"; - const SELECTOR: [u8; 4] = [194u8, 153u8, 130u8, 56u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.cTokens), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: enterMarketsReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: enterMarketsReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `exitMarket(address)` and selector `0xede4edd0`. -```solidity -function exitMarket(address) external pure returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct exitMarketCall(pub alloy::sol_types::private::Address); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`exitMarket(address)`](exitMarketCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct exitMarketReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: exitMarketCall) -> Self { - (value.0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for exitMarketCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self(tuple.0) - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: exitMarketReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for exitMarketReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for exitMarketCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "exitMarket(address)"; - const SELECTOR: [u8; 4] = [237u8, 228u8, 237u8, 208u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.0, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: exitMarketReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: exitMarketReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`DummyIonicPool`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum DummyIonicPoolCalls { - #[allow(missing_docs)] - enterMarkets(enterMarketsCall), - #[allow(missing_docs)] - exitMarket(exitMarketCall), - } - #[automatically_derived] - impl DummyIonicPoolCalls { - /// 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]] = &[ - [194u8, 153u8, 130u8, 56u8], - [237u8, 228u8, 237u8, 208u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for DummyIonicPoolCalls { - const NAME: &'static str = "DummyIonicPoolCalls"; - const MIN_DATA_LENGTH: usize = 32usize; - const COUNT: usize = 2usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::enterMarkets(_) => { - ::SELECTOR - } - Self::exitMarket(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn enterMarkets( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummyIonicPoolCalls::enterMarkets) - } - enterMarkets - }, - { - fn exitMarket( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummyIonicPoolCalls::exitMarket) - } - exitMarket - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn enterMarkets( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyIonicPoolCalls::enterMarkets) - } - enterMarkets - }, - { - fn exitMarket( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyIonicPoolCalls::exitMarket) - } - exitMarket - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::enterMarkets(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::exitMarket(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::enterMarkets(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::exitMarket(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`DummyIonicPool`](self) contract instance. - -See the [wrapper's documentation](`DummyIonicPoolInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> DummyIonicPoolInstance { - DummyIonicPoolInstance::::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: alloy_contract::private::Network, - >( - provider: P, - _doEnterMarkets: bool, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - DummyIonicPoolInstance::::deploy(provider, _doEnterMarkets) - } - /**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: alloy_contract::private::Network, - >(provider: P, _doEnterMarkets: bool) -> alloy_contract::RawCallBuilder { - DummyIonicPoolInstance::::deploy_builder(provider, _doEnterMarkets) - } - /**A [`DummyIonicPool`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`DummyIonicPool`](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 DummyIonicPoolInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for DummyIonicPoolInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("DummyIonicPoolInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummyIonicPoolInstance { - /**Creates a new wrapper around an on-chain [`DummyIonicPool`](self) contract instance. - -See the [wrapper's documentation](`DummyIonicPoolInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - _doEnterMarkets: bool, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder(provider, _doEnterMarkets); - 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, - _doEnterMarkets: bool, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { _doEnterMarkets }, - )[..], - ] - .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 DummyIonicPoolInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> DummyIonicPoolInstance { - DummyIonicPoolInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummyIonicPoolInstance { - /// 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( - &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 [`enterMarkets`] function. - pub fn enterMarkets( - &self, - cTokens: alloy::sol_types::private::Vec, - ) -> alloy_contract::SolCallBuilder<&P, enterMarketsCall, N> { - self.call_builder(&enterMarketsCall { cTokens }) - } - ///Creates a new call builder for the [`exitMarket`] function. - pub fn exitMarket( - &self, - _0: alloy::sol_types::private::Address, - ) -> alloy_contract::SolCallBuilder<&P, exitMarketCall, N> { - self.call_builder(&exitMarketCall(_0)) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummyIonicPoolInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/dummy_ionic_token.rs b/crates/bindings/src/dummy_ionic_token.rs deleted file mode 100644 index 1553bda2a..000000000 --- a/crates/bindings/src/dummy_ionic_token.rs +++ /dev/null @@ -1,4713 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface DummyIonicToken { - event Approval(address indexed owner, address indexed spender, uint256 value); - event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); - event Transfer(address indexed from, address indexed to, uint256 value); - - constructor(string name_, string symbol_, bool _doMint, bool _suppressMintError); - - 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 mint(uint256 mintAmount) external returns (uint256); - function name() external view returns (string memory); - function owner() external view returns (address); - function redeem(uint256) external pure returns (uint256); - function renounceOwnership() external; - function sudoMint(address to, uint256 amount) external; - function symbol() external view returns (string memory); - function totalSupply() external view returns (uint256); - function transfer(address to, uint256 amount) external returns (bool); - function transferFrom(address from, address to, uint256 amount) external returns (bool); - function transferOwnership(address newOwner) external; -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "name_", - "type": "string", - "internalType": "string" - }, - { - "name": "symbol_", - "type": "string", - "internalType": "string" - }, - { - "name": "_doMint", - "type": "bool", - "internalType": "bool" - }, - { - "name": "_suppressMintError", - "type": "bool", - "internalType": "bool" - } - ], - "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": "mint", - "inputs": [ - { - "name": "mintAmount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "name", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "string", - "internalType": "string" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "owner", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "address" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "redeem", - "inputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "pure" - }, - { - "type": "function", - "name": "renounceOwnership", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "sudoMint", - "inputs": [ - { - "name": "to", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "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": "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" - }, - { - "type": "function", - "name": "transferOwnership", - "inputs": [ - { - "name": "newOwner", - "type": "address", - "internalType": "address" - } - ], - "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": "OwnershipTransferred", - "inputs": [ - { - "name": "previousOwner", - "type": "address", - "indexed": true, - "internalType": "address" - }, - { - "name": "newOwner", - "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 DummyIonicToken { - use super::*; - use alloy::sol_types as 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__\xFD[P`@Qa\x11U8\x03\x80a\x11U\x839\x81\x01`@\x81\x90Ra\0.\x91a\x01\xA2V[\x83\x83`\x03a\0<\x83\x82a\x02\xABV[P`\x04a\0I\x82\x82a\x02\xABV[PPPa\0ba\0]a\0\x9C` \x1B` \x1CV[a\0\xA0V[`\x05\x80Ta\xFF\xFF`\xA0\x1B\x19\x16`\x01`\xA0\x1B\x93\x15\x15\x93\x90\x93\x02`\xFF`\xA8\x1B\x19\x16\x92\x90\x92\x17`\x01`\xA8\x1B\x91\x15\x15\x91\x90\x91\x02\x17\x90UPa\x03e\x90PV[3\x90V[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x01`\x01`\xA0\x1B\x03\x19\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x82`\x1F\x83\x01\x12a\x01\x14W__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01-Wa\x01-a\0\xF1V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x01[Wa\x01[a\0\xF1V[`@R\x81\x81R\x83\x82\x01` \x01\x85\x10\x15a\x01rW__\xFD[\x81` \x85\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[\x80Q\x80\x15\x15\x81\x14a\x01\x9DW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x01\xB5W__\xFD[\x84Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\xCAW__\xFD[a\x01\xD6\x87\x82\x88\x01a\x01\x05V[` \x87\x01Q\x90\x95P\x90P`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\xF3W__\xFD[a\x01\xFF\x87\x82\x88\x01a\x01\x05V[\x93PPa\x02\x0E`@\x86\x01a\x01\x8EV[\x91Pa\x02\x1C``\x86\x01a\x01\x8EV[\x90P\x92\x95\x91\x94P\x92PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x02;W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x02YWcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\x02\xA6W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x02\x84WP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x02\xA3W_\x81U`\x01\x01a\x02\x90V[PP[PPPV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x02\xC4Wa\x02\xC4a\0\xF1V[a\x02\xD8\x81a\x02\xD2\x84Ta\x02'V[\x84a\x02_V[` `\x1F\x82\x11`\x01\x81\x14a\x03\nW_\x83\x15a\x02\xF3WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x02\xA3V[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x039W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x03\x19V[P\x84\x82\x10\x15a\x03VW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[a\r\xE3\x80a\x03r_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cqP\x18\xA6\x11a\0\xADW\x80c\xA4W\xC2\xD7\x11a\0}W\x80c\xDB\0ju\x11a\0cW\x80c\xDB\0ju\x14a\x02BW\x80c\xDDb\xED>\x14a\x02UW\x80c\xF2\xFD\xE3\x8B\x14a\x02\x8DW__\xFD[\x80c\xA4W\xC2\xD7\x14a\x02\x1CW\x80c\xA9\x05\x9C\xBB\x14a\x02/W__\xFD[\x80cqP\x18\xA6\x14a\x01\xDEW\x80c\x8D\xA5\xCB[\x14a\x01\xE6W\x80c\x95\xD8\x9BA\x14a\x02\x01W\x80c\xA0q-h\x14a\x02\tW__\xFD[\x80c-h\x8C\xA8\x11a\0\xE8W\x80c-h\x8C\xA8\x14a\x01\x7FW\x80c1<\xE5g\x14a\x01\x94W\x80c9P\x93Q\x14a\x01\xA3W\x80cp\xA0\x821\x14a\x01\xB6W__\xFD[\x80c\x06\xFD\xDE\x03\x14a\x01\x19W\x80c\t^\xA7\xB3\x14a\x017W\x80c\x18\x16\r\xDD\x14a\x01ZW\x80c#\xB8r\xDD\x14a\x01lW[__\xFD[a\x01!a\x02\xA0V[`@Qa\x01.\x91\x90a\x0B\xECV[`@Q\x80\x91\x03\x90\xF3[a\x01Ja\x01E6`\x04a\x0CZV[a\x030V[`@Q\x90\x15\x15\x81R` \x01a\x01.V[`\x02T[`@Q\x90\x81R` \x01a\x01.V[a\x01Ja\x01z6`\x04a\x0C\x82V[a\x03IV[a\x01\x92a\x01\x8D6`\x04a\x0CZV[a\x03lV[\0[`@Q`\x12\x81R` \x01a\x01.V[a\x01Ja\x01\xB16`\x04a\x0CZV[a\x03\xD9V[a\x01^a\x01\xC46`\x04a\x0C\xBCV[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R` \x81\x90R`@\x90 T\x90V[a\x01\x92a\x04\x17V[`\x05T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01.V[a\x01!a\x04|V[a\x01^a\x02\x176`\x04a\x0C\xDCV[a\x04\x8BV[a\x01Ja\x02*6`\x04a\x0CZV[a\x04\xF4V[a\x01Ja\x02=6`\x04a\x0CZV[a\x05\x9DV[a\x01^a\x02P6`\x04a\x0C\xDCV[P_\x90V[a\x01^a\x02c6`\x04a\x0C\xF3V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[a\x01\x92a\x02\x9B6`\x04a\x0C\xBCV[a\x05\xAAV[```\x03\x80Ta\x02\xAF\x90a\r$V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\xDB\x90a\r$V[\x80\x15a\x03&W\x80`\x1F\x10a\x02\xFDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03&V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\tW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[_3a\x03=\x81\x85\x85a\x06\x8CV[`\x01\x91PP[\x92\x91PPV[_3a\x03V\x85\x82\x85a\x07\xE3V[a\x03a\x85\x85\x85a\x08\x92V[P`\x01\x94\x93PPPPV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x03\xCBW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\xD5\x82\x82a\n\xA7V[PPV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90a\x03=\x90\x82\x90\x86\x90a\x04\x12\x90\x87\x90a\ruV[a\x06\x8CV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x04qW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03\xC2V[a\x04z_a\x0B\x83V[V[```\x04\x80Ta\x02\xAF\x90a\r$V[`\x05T_\x90u\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x04\xB8WP_\x91\x90PV[`\x05Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x04\xECWa\x04\xE53\x83a\n\xA7V[P_\x91\x90PV[P`\x01\x91\x90PV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90\x83\x81\x10\x15a\x05\x90W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[a\x03a\x82\x86\x86\x84\x03a\x06\x8CV[_3a\x03=\x81\x85\x85a\x08\x92V[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x06\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x06\x80W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01R\x7Fddress\0\0\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\x03\xC2V[a\x06\x89\x81a\x0B\x83V[PV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x07\x07W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x07\x83W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\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[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R 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\x81\x14a\x08\x8CW\x81\x81\x10\x15a\x08\x7FW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FERC20: insufficient allowance\0\0\0`D\x82\x01R`d\x01a\x03\xC2V[a\x08\x8C\x84\x84\x84\x84\x03a\x06\x8CV[PPPPV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\t\x0EW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\t\x8AW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R` \x81\x90R`@\x90 T\x81\x81\x10\x15a\n\x18W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16_\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R\x90\x81 \x80T\x84\x92\x90a\nN\x90\x84\x90a\ruV[\x92PP\x81\x90UP\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\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\n\x9A\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3a\x08\x8CV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\n\xFDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FERC20: mint to the zero address\0`D\x82\x01R`d\x01a\x03\xC2V[\x80`\x02_\x82\x82Ta\x0B\x0E\x91\x90a\ruV[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x83\x92\x90a\x0B:\x90\x84\x90a\ruV[\x90\x91UPP`@Q\x81\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90_\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[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\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\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\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\x84\x01\x01\x91PP\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0CUW__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0CkW__\xFD[a\x0Ct\x83a\x0C?V[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x0C\x94W__\xFD[a\x0C\x9D\x84a\x0C?V[\x92Pa\x0C\xAB` \x85\x01a\x0C?V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\x0C\xCCW__\xFD[a\x0C\xD5\x82a\x0C?V[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x0C\xECW__\xFD[P5\x91\x90PV[__`@\x83\x85\x03\x12\x15a\r\x04W__\xFD[a\r\r\x83a\x0C?V[\x91Pa\r\x1B` \x84\x01a\x0C?V[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\r8W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\roW\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[P\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x03CW\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\xFE\xA2dipfsX\"\x12 Vn\xA9sL\xF4\x94:\xB1\x9A\xB4G\xAAe\x9A\xC7\x1E\xADVze\x8A7\xDEP\xFE\xCF\x03\xA6\xE6\xA0\xCAdsolcC\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\x01\x15W_5`\xE0\x1C\x80cqP\x18\xA6\x11a\0\xADW\x80c\xA4W\xC2\xD7\x11a\0}W\x80c\xDB\0ju\x11a\0cW\x80c\xDB\0ju\x14a\x02BW\x80c\xDDb\xED>\x14a\x02UW\x80c\xF2\xFD\xE3\x8B\x14a\x02\x8DW__\xFD[\x80c\xA4W\xC2\xD7\x14a\x02\x1CW\x80c\xA9\x05\x9C\xBB\x14a\x02/W__\xFD[\x80cqP\x18\xA6\x14a\x01\xDEW\x80c\x8D\xA5\xCB[\x14a\x01\xE6W\x80c\x95\xD8\x9BA\x14a\x02\x01W\x80c\xA0q-h\x14a\x02\tW__\xFD[\x80c-h\x8C\xA8\x11a\0\xE8W\x80c-h\x8C\xA8\x14a\x01\x7FW\x80c1<\xE5g\x14a\x01\x94W\x80c9P\x93Q\x14a\x01\xA3W\x80cp\xA0\x821\x14a\x01\xB6W__\xFD[\x80c\x06\xFD\xDE\x03\x14a\x01\x19W\x80c\t^\xA7\xB3\x14a\x017W\x80c\x18\x16\r\xDD\x14a\x01ZW\x80c#\xB8r\xDD\x14a\x01lW[__\xFD[a\x01!a\x02\xA0V[`@Qa\x01.\x91\x90a\x0B\xECV[`@Q\x80\x91\x03\x90\xF3[a\x01Ja\x01E6`\x04a\x0CZV[a\x030V[`@Q\x90\x15\x15\x81R` \x01a\x01.V[`\x02T[`@Q\x90\x81R` \x01a\x01.V[a\x01Ja\x01z6`\x04a\x0C\x82V[a\x03IV[a\x01\x92a\x01\x8D6`\x04a\x0CZV[a\x03lV[\0[`@Q`\x12\x81R` \x01a\x01.V[a\x01Ja\x01\xB16`\x04a\x0CZV[a\x03\xD9V[a\x01^a\x01\xC46`\x04a\x0C\xBCV[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R` \x81\x90R`@\x90 T\x90V[a\x01\x92a\x04\x17V[`\x05T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01.V[a\x01!a\x04|V[a\x01^a\x02\x176`\x04a\x0C\xDCV[a\x04\x8BV[a\x01Ja\x02*6`\x04a\x0CZV[a\x04\xF4V[a\x01Ja\x02=6`\x04a\x0CZV[a\x05\x9DV[a\x01^a\x02P6`\x04a\x0C\xDCV[P_\x90V[a\x01^a\x02c6`\x04a\x0C\xF3V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[a\x01\x92a\x02\x9B6`\x04a\x0C\xBCV[a\x05\xAAV[```\x03\x80Ta\x02\xAF\x90a\r$V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\xDB\x90a\r$V[\x80\x15a\x03&W\x80`\x1F\x10a\x02\xFDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03&V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\tW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[_3a\x03=\x81\x85\x85a\x06\x8CV[`\x01\x91PP[\x92\x91PPV[_3a\x03V\x85\x82\x85a\x07\xE3V[a\x03a\x85\x85\x85a\x08\x92V[P`\x01\x94\x93PPPPV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x03\xCBW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\xD5\x82\x82a\n\xA7V[PPV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90a\x03=\x90\x82\x90\x86\x90a\x04\x12\x90\x87\x90a\ruV[a\x06\x8CV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x04qW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03\xC2V[a\x04z_a\x0B\x83V[V[```\x04\x80Ta\x02\xAF\x90a\r$V[`\x05T_\x90u\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x04\xB8WP_\x91\x90PV[`\x05Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x04\xECWa\x04\xE53\x83a\n\xA7V[P_\x91\x90PV[P`\x01\x91\x90PV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90\x83\x81\x10\x15a\x05\x90W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[a\x03a\x82\x86\x86\x84\x03a\x06\x8CV[_3a\x03=\x81\x85\x85a\x08\x92V[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x06\x04W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x06\x80W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01R\x7Fddress\0\0\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\x03\xC2V[a\x06\x89\x81a\x0B\x83V[PV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x07\x07W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x07\x83W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\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[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R 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\x81\x14a\x08\x8CW\x81\x81\x10\x15a\x08\x7FW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FERC20: insufficient allowance\0\0\0`D\x82\x01R`d\x01a\x03\xC2V[a\x08\x8C\x84\x84\x84\x84\x03a\x06\x8CV[PPPPV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\t\x0EW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\t\x8AW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R` \x81\x90R`@\x90 T\x81\x81\x10\x15a\n\x18W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16_\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R\x90\x81 \x80T\x84\x92\x90a\nN\x90\x84\x90a\ruV[\x92PP\x81\x90UP\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\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\n\x9A\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3a\x08\x8CV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\n\xFDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FERC20: mint to the zero address\0`D\x82\x01R`d\x01a\x03\xC2V[\x80`\x02_\x82\x82Ta\x0B\x0E\x91\x90a\ruV[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x83\x92\x90a\x0B:\x90\x84\x90a\ruV[\x90\x91UPP`@Q\x81\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90_\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[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\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\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\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\x84\x01\x01\x91PP\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0CUW__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0CkW__\xFD[a\x0Ct\x83a\x0C?V[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x0C\x94W__\xFD[a\x0C\x9D\x84a\x0C?V[\x92Pa\x0C\xAB` \x85\x01a\x0C?V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\x0C\xCCW__\xFD[a\x0C\xD5\x82a\x0C?V[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x0C\xECW__\xFD[P5\x91\x90PV[__`@\x83\x85\x03\x12\x15a\r\x04W__\xFD[a\r\r\x83a\x0C?V[\x91Pa\r\x1B` \x84\x01a\x0C?V[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\r8W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\roW\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[P\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x03CW\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\xFE\xA2dipfsX\"\x12 Vn\xA9sL\xF4\x94:\xB1\x9A\xB4G\xAAe\x9A\xC7\x1E\xADVze\x8A7\xDEP\xFE\xCF\x03\xA6\xE6\xA0\xCAdsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for Approval { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - 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, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - owner: topics.1, - spender: topics.2, - value: data.0, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.value), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = ::encode_topic( - &self.owner, - ); - out[2usize] = ::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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for OwnershipTransferred { - type DataTuple<'a> = (); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - 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, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - previousOwner: topics.1, - newOwner: topics.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return 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) -> ::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() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = ::encode_topic( - &self.previousOwner, - ); - out[2usize] = ::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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for Transfer { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - 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, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - from: topics.1, - to: topics.2, - value: data.0, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.value), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = ::encode_topic( - &self.from, - ); - out[2usize] = ::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_, bool _doMint, bool _suppressMintError); -```*/ - #[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, - #[allow(missing_docs)] - pub _doMint: bool, - #[allow(missing_docs)] - pub _suppressMintError: bool, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bool, - alloy::sol_types::sol_data::Bool, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::String, - bool, - bool, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value.name_, value.symbol_, value._doMint, value._suppressMintError) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - name_: tuple.0, - symbol_: tuple.1, - _doMint: tuple.2, - _suppressMintError: tuple.3, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolConstructor for constructorCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bool, - alloy::sol_types::sol_data::Bool, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.name_, - ), - ::tokenize( - &self.symbol_, - ), - ::tokenize( - &self._doMint, - ), - ::tokenize( - &self._suppressMintError, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: allowanceCall) -> Self { - (value.owner, value.spender) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for allowanceCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - owner: tuple.0, - spender: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: allowanceReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "allowance(address,address)"; - const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.owner, - ), - ::tokenize( - &self.spender, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: allowanceReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: approveCall) -> Self { - (value.spender, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for approveCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - spender: tuple.0, - amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: approveReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "approve(address,uint256)"; - const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.spender, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: approveReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: balanceOfCall) -> Self { - (value.account,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for balanceOfCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { account: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: balanceOfReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "balanceOf(address)"; - const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.account, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: balanceOfReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: decimalsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for decimalsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: decimalsReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for decimalsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for decimalsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = u8; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "decimals()"; - const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: decimalsReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: decreaseAllowanceCall) -> Self { - (value.spender, value.subtractedValue) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for decreaseAllowanceCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - spender: tuple.0, - subtractedValue: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: decreaseAllowanceReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)"; - const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.spender, - ), - as alloy_sol_types::SolType>::tokenize(&self.subtractedValue), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: decreaseAllowanceReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: increaseAllowanceCall) -> Self { - (value.spender, value.addedValue) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for increaseAllowanceCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - spender: tuple.0, - addedValue: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: increaseAllowanceReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "increaseAllowance(address,uint256)"; - const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.spender, - ), - as alloy_sol_types::SolType>::tokenize(&self.addedValue), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: increaseAllowanceReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `mint(uint256)` and selector `0xa0712d68`. -```solidity -function mint(uint256 mintAmount) external returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct mintCall { - #[allow(missing_docs)] - pub mintAmount: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`mint(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: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: mintCall) -> Self { - (value.mintAmount,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for mintCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { mintAmount: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: mintReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "mint(uint256)"; - const SELECTOR: [u8; 4] = [160u8, 113u8, 45u8, 104u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.mintAmount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: mintReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: nameCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for nameCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: nameReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for nameReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for nameCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::String; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "name()"; - const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: nameReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: ownerCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for ownerCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: ownerReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for ownerReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for ownerCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "owner()"; - const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: ownerReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `redeem(uint256)` and selector `0xdb006a75`. -```solidity -function redeem(uint256) external pure returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct redeemCall(pub alloy::sol_types::private::primitives::aliases::U256); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`redeem(uint256)`](redeemCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct redeemReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: redeemCall) -> Self { - (value.0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for redeemCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self(tuple.0) - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: redeemReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for redeemReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for redeemCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "redeem(uint256)"; - const SELECTOR: [u8; 4] = [219u8, 0u8, 106u8, 117u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.0), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: redeemReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: redeemReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: renounceOwnershipCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for renounceOwnershipCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: renounceOwnershipReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for renounceOwnershipReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl renounceOwnershipReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for renounceOwnershipCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = renounceOwnershipReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "renounceOwnership()"; - const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8]; - #[inline] - fn new<'a>( - tuple: 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 { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `sudoMint(address,uint256)` and selector `0x2d688ca8`. -```solidity -function sudoMint(address to, uint256 amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct sudoMintCall { - #[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 [`sudoMint(address,uint256)`](sudoMintCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct sudoMintReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: sudoMintCall) -> Self { - (value.to, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for sudoMintCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - to: tuple.0, - amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: sudoMintReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for sudoMintReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl sudoMintReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for sudoMintCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = sudoMintReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "sudoMint(address,uint256)"; - const SELECTOR: [u8; 4] = [45u8, 104u8, 140u8, 168u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.to, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - sudoMintReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: symbolCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for symbolCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: symbolReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for symbolReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for symbolCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::String; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "symbol()"; - const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: symbolReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: totalSupplyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for totalSupplyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: totalSupplyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for totalSupplyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for totalSupplyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "totalSupply()"; - const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: totalSupplyReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferCall) -> Self { - (value.to, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for transferCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - to: tuple.0, - amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "transfer(address,uint256)"; - const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.to, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: transferReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferFromCall) -> Self { - (value.from, value.to, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for transferFromCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - from: tuple.0, - to: tuple.1, - amount: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferFromReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "transferFrom(address,address,uint256)"; - const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.from, - ), - ::tokenize( - &self.to, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: transferFromReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: transferOwnershipCall) -> Self { - (value.newOwner,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for transferOwnershipCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { newOwner: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: transferOwnershipReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for transferOwnershipReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl transferOwnershipReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for transferOwnershipCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = transferOwnershipReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "transferOwnership(address)"; - const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::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 { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`DummyIonicToken`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum DummyIonicTokenCalls { - #[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)] - mint(mintCall), - #[allow(missing_docs)] - name(nameCall), - #[allow(missing_docs)] - owner(ownerCall), - #[allow(missing_docs)] - redeem(redeemCall), - #[allow(missing_docs)] - renounceOwnership(renounceOwnershipCall), - #[allow(missing_docs)] - sudoMint(sudoMintCall), - #[allow(missing_docs)] - symbol(symbolCall), - #[allow(missing_docs)] - totalSupply(totalSupplyCall), - #[allow(missing_docs)] - transfer(transferCall), - #[allow(missing_docs)] - transferFrom(transferFromCall), - #[allow(missing_docs)] - transferOwnership(transferOwnershipCall), - } - #[automatically_derived] - impl DummyIonicTokenCalls { - /// 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], - [45u8, 104u8, 140u8, 168u8], - [49u8, 60u8, 229u8, 103u8], - [57u8, 80u8, 147u8, 81u8], - [112u8, 160u8, 130u8, 49u8], - [113u8, 80u8, 24u8, 166u8], - [141u8, 165u8, 203u8, 91u8], - [149u8, 216u8, 155u8, 65u8], - [160u8, 113u8, 45u8, 104u8], - [164u8, 87u8, 194u8, 215u8], - [169u8, 5u8, 156u8, 187u8], - [219u8, 0u8, 106u8, 117u8], - [221u8, 98u8, 237u8, 62u8], - [242u8, 253u8, 227u8, 139u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for DummyIonicTokenCalls { - const NAME: &'static str = "DummyIonicTokenCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 17usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::allowance(_) => { - ::SELECTOR - } - Self::approve(_) => ::SELECTOR, - Self::balanceOf(_) => { - ::SELECTOR - } - Self::decimals(_) => ::SELECTOR, - Self::decreaseAllowance(_) => { - ::SELECTOR - } - Self::increaseAllowance(_) => { - ::SELECTOR - } - Self::mint(_) => ::SELECTOR, - Self::name(_) => ::SELECTOR, - Self::owner(_) => ::SELECTOR, - Self::redeem(_) => ::SELECTOR, - Self::renounceOwnership(_) => { - ::SELECTOR - } - Self::sudoMint(_) => ::SELECTOR, - Self::symbol(_) => ::SELECTOR, - Self::totalSupply(_) => { - ::SELECTOR - } - Self::transfer(_) => ::SELECTOR, - Self::transferFrom(_) => { - ::SELECTOR - } - Self::transferOwnership(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn name( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyIonicTokenCalls::name) - } - name - }, - { - fn approve( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyIonicTokenCalls::approve) - } - approve - }, - { - fn totalSupply( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummyIonicTokenCalls::totalSupply) - } - totalSupply - }, - { - fn transferFrom( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummyIonicTokenCalls::transferFrom) - } - transferFrom - }, - { - fn sudoMint( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyIonicTokenCalls::sudoMint) - } - sudoMint - }, - { - fn decimals( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyIonicTokenCalls::decimals) - } - decimals - }, - { - fn increaseAllowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummyIonicTokenCalls::increaseAllowance) - } - increaseAllowance - }, - { - fn balanceOf( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyIonicTokenCalls::balanceOf) - } - balanceOf - }, - { - fn renounceOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummyIonicTokenCalls::renounceOwnership) - } - renounceOwnership - }, - { - fn owner( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyIonicTokenCalls::owner) - } - owner - }, - { - fn symbol( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyIonicTokenCalls::symbol) - } - symbol - }, - { - fn mint( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyIonicTokenCalls::mint) - } - mint - }, - { - fn decreaseAllowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummyIonicTokenCalls::decreaseAllowance) - } - decreaseAllowance - }, - { - fn transfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyIonicTokenCalls::transfer) - } - transfer - }, - { - fn redeem( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyIonicTokenCalls::redeem) - } - redeem - }, - { - fn allowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyIonicTokenCalls::allowance) - } - allowance - }, - { - fn transferOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummyIonicTokenCalls::transferOwnership) - } - transferOwnership - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn name( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyIonicTokenCalls::name) - } - name - }, - { - fn approve( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyIonicTokenCalls::approve) - } - approve - }, - { - fn totalSupply( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyIonicTokenCalls::totalSupply) - } - totalSupply - }, - { - fn transferFrom( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyIonicTokenCalls::transferFrom) - } - transferFrom - }, - { - fn sudoMint( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyIonicTokenCalls::sudoMint) - } - sudoMint - }, - { - fn decimals( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyIonicTokenCalls::decimals) - } - decimals - }, - { - fn increaseAllowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyIonicTokenCalls::increaseAllowance) - } - increaseAllowance - }, - { - fn balanceOf( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyIonicTokenCalls::balanceOf) - } - balanceOf - }, - { - fn renounceOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyIonicTokenCalls::renounceOwnership) - } - renounceOwnership - }, - { - fn owner( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyIonicTokenCalls::owner) - } - owner - }, - { - fn symbol( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyIonicTokenCalls::symbol) - } - symbol - }, - { - fn mint( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyIonicTokenCalls::mint) - } - mint - }, - { - fn decreaseAllowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyIonicTokenCalls::decreaseAllowance) - } - decreaseAllowance - }, - { - fn transfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyIonicTokenCalls::transfer) - } - transfer - }, - { - fn redeem( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyIonicTokenCalls::redeem) - } - redeem - }, - { - fn allowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyIonicTokenCalls::allowance) - } - allowance - }, - { - fn transferOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyIonicTokenCalls::transferOwnership) - } - transferOwnership - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::allowance(inner) => { - ::abi_encoded_size(inner) - } - Self::approve(inner) => { - ::abi_encoded_size(inner) - } - Self::balanceOf(inner) => { - ::abi_encoded_size(inner) - } - Self::decimals(inner) => { - ::abi_encoded_size(inner) - } - Self::decreaseAllowance(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::increaseAllowance(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::mint(inner) => { - ::abi_encoded_size(inner) - } - Self::name(inner) => { - ::abi_encoded_size(inner) - } - Self::owner(inner) => { - ::abi_encoded_size(inner) - } - Self::redeem(inner) => { - ::abi_encoded_size(inner) - } - Self::renounceOwnership(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::sudoMint(inner) => { - ::abi_encoded_size(inner) - } - Self::symbol(inner) => { - ::abi_encoded_size(inner) - } - Self::totalSupply(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::transfer(inner) => { - ::abi_encoded_size(inner) - } - Self::transferFrom(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::transferOwnership(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::allowance(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::approve(inner) => { - ::abi_encode_raw(inner, out) - } - Self::balanceOf(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::decimals(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::decreaseAllowance(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::increaseAllowance(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::mint(inner) => { - ::abi_encode_raw(inner, out) - } - Self::name(inner) => { - ::abi_encode_raw(inner, out) - } - Self::owner(inner) => { - ::abi_encode_raw(inner, out) - } - Self::redeem(inner) => { - ::abi_encode_raw(inner, out) - } - Self::renounceOwnership(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::sudoMint(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::symbol(inner) => { - ::abi_encode_raw(inner, out) - } - Self::totalSupply(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::transfer(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::transferFrom(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::transferOwnership(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`DummyIonicToken`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum DummyIonicTokenEvents { - #[allow(missing_docs)] - Approval(Approval), - #[allow(missing_docs)] - OwnershipTransferred(OwnershipTransferred), - #[allow(missing_docs)] - Transfer(Transfer), - } - #[automatically_derived] - impl DummyIonicTokenEvents { - /// 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]] = &[ - [ - 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, 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, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for DummyIonicTokenEvents { - const NAME: &'static str = "DummyIonicTokenEvents"; - const COUNT: usize = 3usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::Approval) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::OwnershipTransferred) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::Transfer) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 DummyIonicTokenEvents { - 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::OwnershipTransferred(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::OwnershipTransferred(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 as alloy_contract; - /**Creates a new wrapper around an on-chain [`DummyIonicToken`](self) contract instance. - -See the [wrapper's documentation](`DummyIonicTokenInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> DummyIonicTokenInstance { - DummyIonicTokenInstance::::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: alloy_contract::private::Network, - >( - provider: P, - name_: alloy::sol_types::private::String, - symbol_: alloy::sol_types::private::String, - _doMint: bool, - _suppressMintError: bool, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - DummyIonicTokenInstance::< - P, - N, - >::deploy(provider, name_, symbol_, _doMint, _suppressMintError) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - name_: alloy::sol_types::private::String, - symbol_: alloy::sol_types::private::String, - _doMint: bool, - _suppressMintError: bool, - ) -> alloy_contract::RawCallBuilder { - DummyIonicTokenInstance::< - P, - N, - >::deploy_builder(provider, name_, symbol_, _doMint, _suppressMintError) - } - /**A [`DummyIonicToken`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`DummyIonicToken`](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 DummyIonicTokenInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for DummyIonicTokenInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("DummyIonicTokenInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummyIonicTokenInstance { - /**Creates a new wrapper around an on-chain [`DummyIonicToken`](self) contract instance. - -See the [wrapper's documentation](`DummyIonicTokenInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - name_: alloy::sol_types::private::String, - symbol_: alloy::sol_types::private::String, - _doMint: bool, - _suppressMintError: bool, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder( - provider, - name_, - symbol_, - _doMint, - _suppressMintError, - ); - 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, - name_: alloy::sol_types::private::String, - symbol_: alloy::sol_types::private::String, - _doMint: bool, - _suppressMintError: bool, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { - name_, - symbol_, - _doMint, - _suppressMintError, - }, - )[..], - ] - .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 DummyIonicTokenInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> DummyIonicTokenInstance { - DummyIonicTokenInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummyIonicTokenInstance { - /// 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( - &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 [`mint`] function. - pub fn mint( - &self, - mintAmount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> { - self.call_builder(&mintCall { mintAmount }) - } - ///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 [`redeem`] function. - pub fn redeem( - &self, - _0: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, redeemCall, N> { - self.call_builder(&redeemCall(_0)) - } - ///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 [`sudoMint`] function. - pub fn sudoMint( - &self, - to: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, sudoMintCall, N> { - self.call_builder(&sudoMintCall { to, amount }) - } - ///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, - 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, - }, - ) - } - ///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. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummyIonicTokenInstance { - /// 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( - &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::() - } - ///Creates a new event filter for the [`OwnershipTransferred`] event. - pub fn OwnershipTransferred_filter( - &self, - ) -> alloy_contract::Event<&P, OwnershipTransferred, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`Transfer`] event. - pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/dummy_pell_strategy.rs b/crates/bindings/src/dummy_pell_strategy.rs deleted file mode 100644 index c65bf308c..000000000 --- a/crates/bindings/src/dummy_pell_strategy.rs +++ /dev/null @@ -1,218 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface DummyPellStrategy {} -``` - -...which was generated by the following JSON ABI: -```json -[] -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod DummyPellStrategy { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x6080604052348015600e575f5ffd5b50603e80601a5f395ff3fe60806040525f5ffdfea264697066735822122045f7292c77568df36e723757ab30c5367b3fb087c1497d4353e1d25d621982cc64736f6c634300081c0033 - /// ``` - #[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`>\x80`\x1A_9_\xF3\xFE`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 E\xF7),wV\x8D\xF3nr7W\xAB0\xC56{?\xB0\x87\xC1I}CS\xE1\xD2]b\x19\x82\xCCdsolcC\0\x08\x1C\x003", - ); - /// The runtime bytecode of the contract, as deployed on the network. - /// - /// ```text - ///0x60806040525f5ffdfea264697066735822122045f7292c77568df36e723757ab30c5367b3fb087c1497d4353e1d25d621982cc64736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 E\xF7),wV\x8D\xF3nr7W\xAB0\xC56{?\xB0\x87\xC1I}CS\xE1\xD2]b\x19\x82\xCCdsolcC\0\x08\x1C\x003", - ); - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`DummyPellStrategy`](self) contract instance. - -See the [wrapper's documentation](`DummyPellStrategyInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> DummyPellStrategyInstance { - DummyPellStrategyInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - DummyPellStrategyInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - DummyPellStrategyInstance::::deploy_builder(provider) - } - /**A [`DummyPellStrategy`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`DummyPellStrategy`](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 DummyPellStrategyInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for DummyPellStrategyInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("DummyPellStrategyInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummyPellStrategyInstance { - /**Creates a new wrapper around an on-chain [`DummyPellStrategy`](self) contract instance. - -See the [wrapper's documentation](`DummyPellStrategyInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 DummyPellStrategyInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> DummyPellStrategyInstance { - DummyPellStrategyInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummyPellStrategyInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummyPellStrategyInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/dummy_pell_strategy_manager.rs b/crates/bindings/src/dummy_pell_strategy_manager.rs deleted file mode 100644 index 2b90110f2..000000000 --- a/crates/bindings/src/dummy_pell_strategy_manager.rs +++ /dev/null @@ -1,838 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface DummyPellStrategyManager { - function depositIntoStrategyWithStaker(address, address, address, uint256 amount) external pure returns (uint256 shares); - function stakerStrategyShares(address, address) external pure returns (uint256); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "depositIntoStrategyWithStaker", - "inputs": [ - { - "name": "", - "type": "address", - "internalType": "address" - }, - { - "name": "", - "type": "address", - "internalType": "contract IPellStrategy" - }, - { - "name": "", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "shares", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "pure" - }, - { - "type": "function", - "name": "stakerStrategyShares", - "inputs": [ - { - "name": "", - "type": "address", - "internalType": "address" - }, - { - "name": "", - "type": "address", - "internalType": "contract IPellStrategy" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "pure" - } -] -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod DummyPellStrategyManager { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x6080604052348015600e575f5ffd5b506101538061001c5f395ff3fe608060405234801561000f575f5ffd5b5060043610610034575f3560e01c80637a7e0d9214610038578063e46842b71461005f575b5f5ffd5b61004d610046366004610098565b5f92915050565b60405190815260200160405180910390f35b61004d61006d3660046100cf565b9392505050565b73ffffffffffffffffffffffffffffffffffffffff81168114610095575f5ffd5b50565b5f5f604083850312156100a9575f5ffd5b82356100b481610074565b915060208301356100c481610074565b809150509250929050565b5f5f5f5f608085870312156100e2575f5ffd5b84356100ed81610074565b935060208501356100fd81610074565b9250604085013561010d81610074565b939692955092936060013592505056fea2646970667358221220e239b4156f962c3bf171057532c3c6d8605e9b8f555a1035740ad3627dd8d4b764736f6c634300081c0033 - /// ``` - #[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\x01S\x80a\0\x1C_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x004W_5`\xE0\x1C\x80cz~\r\x92\x14a\08W\x80c\xE4hB\xB7\x14a\0_W[__\xFD[a\0Ma\0F6`\x04a\0\x98V[_\x92\x91PPV[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[a\0Ma\0m6`\x04a\0\xCFV[\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\0\x95W__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0\xA9W__\xFD[\x825a\0\xB4\x81a\0tV[\x91P` \x83\x015a\0\xC4\x81a\0tV[\x80\x91PP\x92P\x92\x90PV[____`\x80\x85\x87\x03\x12\x15a\0\xE2W__\xFD[\x845a\0\xED\x81a\0tV[\x93P` \x85\x015a\0\xFD\x81a\0tV[\x92P`@\x85\x015a\x01\r\x81a\0tV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV\xFE\xA2dipfsX\"\x12 \xE29\xB4\x15o\x96,;\xF1q\x05u2\xC3\xC6\xD8`^\x9B\x8FUZ\x105t\n\xD3b}\xD8\xD4\xB7dsolcC\0\x08\x1C\x003", - ); - /// The runtime bytecode of the contract, as deployed on the network. - /// - /// ```text - ///0x608060405234801561000f575f5ffd5b5060043610610034575f3560e01c80637a7e0d9214610038578063e46842b71461005f575b5f5ffd5b61004d610046366004610098565b5f92915050565b60405190815260200160405180910390f35b61004d61006d3660046100cf565b9392505050565b73ffffffffffffffffffffffffffffffffffffffff81168114610095575f5ffd5b50565b5f5f604083850312156100a9575f5ffd5b82356100b481610074565b915060208301356100c481610074565b809150509250929050565b5f5f5f5f608085870312156100e2575f5ffd5b84356100ed81610074565b935060208501356100fd81610074565b9250604085013561010d81610074565b939692955092936060013592505056fea2646970667358221220e239b4156f962c3bf171057532c3c6d8605e9b8f555a1035740ad3627dd8d4b764736f6c634300081c0033 - /// ``` - #[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\x80cz~\r\x92\x14a\08W\x80c\xE4hB\xB7\x14a\0_W[__\xFD[a\0Ma\0F6`\x04a\0\x98V[_\x92\x91PPV[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[a\0Ma\0m6`\x04a\0\xCFV[\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\0\x95W__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0\xA9W__\xFD[\x825a\0\xB4\x81a\0tV[\x91P` \x83\x015a\0\xC4\x81a\0tV[\x80\x91PP\x92P\x92\x90PV[____`\x80\x85\x87\x03\x12\x15a\0\xE2W__\xFD[\x845a\0\xED\x81a\0tV[\x93P` \x85\x015a\0\xFD\x81a\0tV[\x92P`@\x85\x015a\x01\r\x81a\0tV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV\xFE\xA2dipfsX\"\x12 \xE29\xB4\x15o\x96,;\xF1q\x05u2\xC3\xC6\xD8`^\x9B\x8FUZ\x105t\n\xD3b}\xD8\xD4\xB7dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `depositIntoStrategyWithStaker(address,address,address,uint256)` and selector `0xe46842b7`. -```solidity -function depositIntoStrategyWithStaker(address, address, address, uint256 amount) external pure returns (uint256 shares); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct depositIntoStrategyWithStakerCall { - #[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 amount: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`depositIntoStrategyWithStaker(address,address,address,uint256)`](depositIntoStrategyWithStakerCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct depositIntoStrategyWithStakerReturn { - #[allow(missing_docs)] - pub shares: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: depositIntoStrategyWithStakerCall) -> Self { - (value._0, value._1, value._2, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for depositIntoStrategyWithStakerCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - _0: tuple.0, - _1: tuple.1, - _2: tuple.2, - amount: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: depositIntoStrategyWithStakerReturn) -> Self { - (value.shares,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for depositIntoStrategyWithStakerReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { shares: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for depositIntoStrategyWithStakerCall { - 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "depositIntoStrategyWithStaker(address,address,address,uint256)"; - const SELECTOR: [u8; 4] = [228u8, 104u8, 66u8, 183u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._0, - ), - ::tokenize( - &self._1, - ), - ::tokenize( - &self._2, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: depositIntoStrategyWithStakerReturn = r.into(); - r.shares - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: depositIntoStrategyWithStakerReturn = r.into(); - r.shares - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `stakerStrategyShares(address,address)` and selector `0x7a7e0d92`. -```solidity -function stakerStrategyShares(address, address) external pure returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct stakerStrategySharesCall { - #[allow(missing_docs)] - pub _0: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub _1: alloy::sol_types::private::Address, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`stakerStrategyShares(address,address)`](stakerStrategySharesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct stakerStrategySharesReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: stakerStrategySharesCall) -> Self { - (value._0, value._1) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for stakerStrategySharesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0, _1: tuple.1 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: stakerStrategySharesReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for stakerStrategySharesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for stakerStrategySharesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "stakerStrategyShares(address,address)"; - const SELECTOR: [u8; 4] = [122u8, 126u8, 13u8, 146u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._0, - ), - ::tokenize( - &self._1, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: stakerStrategySharesReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: stakerStrategySharesReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`DummyPellStrategyManager`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum DummyPellStrategyManagerCalls { - #[allow(missing_docs)] - depositIntoStrategyWithStaker(depositIntoStrategyWithStakerCall), - #[allow(missing_docs)] - stakerStrategyShares(stakerStrategySharesCall), - } - #[automatically_derived] - impl DummyPellStrategyManagerCalls { - /// 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]] = &[ - [122u8, 126u8, 13u8, 146u8], - [228u8, 104u8, 66u8, 183u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for DummyPellStrategyManagerCalls { - const NAME: &'static str = "DummyPellStrategyManagerCalls"; - const MIN_DATA_LENGTH: usize = 64usize; - const COUNT: usize = 2usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::depositIntoStrategyWithStaker(_) => { - ::SELECTOR - } - Self::stakerStrategyShares(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn stakerStrategyShares( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummyPellStrategyManagerCalls::stakerStrategyShares) - } - stakerStrategyShares - }, - { - fn depositIntoStrategyWithStaker( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - DummyPellStrategyManagerCalls::depositIntoStrategyWithStaker, - ) - } - depositIntoStrategyWithStaker - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn stakerStrategyShares( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyPellStrategyManagerCalls::stakerStrategyShares) - } - stakerStrategyShares - }, - { - fn depositIntoStrategyWithStaker( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - DummyPellStrategyManagerCalls::depositIntoStrategyWithStaker, - ) - } - depositIntoStrategyWithStaker - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::depositIntoStrategyWithStaker(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::stakerStrategyShares(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::depositIntoStrategyWithStaker(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::stakerStrategyShares(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`DummyPellStrategyManager`](self) contract instance. - -See the [wrapper's documentation](`DummyPellStrategyManagerInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> DummyPellStrategyManagerInstance { - DummyPellStrategyManagerInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - DummyPellStrategyManagerInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - DummyPellStrategyManagerInstance::::deploy_builder(provider) - } - /**A [`DummyPellStrategyManager`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`DummyPellStrategyManager`](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 DummyPellStrategyManagerInstance< - P, - N = alloy_contract::private::Ethereum, - > { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for DummyPellStrategyManagerInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("DummyPellStrategyManagerInstance") - .field(&self.address) - .finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummyPellStrategyManagerInstance { - /**Creates a new wrapper around an on-chain [`DummyPellStrategyManager`](self) contract instance. - -See the [wrapper's documentation](`DummyPellStrategyManagerInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 DummyPellStrategyManagerInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> DummyPellStrategyManagerInstance { - DummyPellStrategyManagerInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummyPellStrategyManagerInstance { - /// 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( - &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 [`depositIntoStrategyWithStaker`] function. - pub fn depositIntoStrategyWithStaker( - &self, - _0: alloy::sol_types::private::Address, - _1: alloy::sol_types::private::Address, - _2: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, depositIntoStrategyWithStakerCall, N> { - self.call_builder( - &depositIntoStrategyWithStakerCall { - _0, - _1, - _2, - amount, - }, - ) - } - ///Creates a new call builder for the [`stakerStrategyShares`] function. - pub fn stakerStrategyShares( - &self, - _0: alloy::sol_types::private::Address, - _1: alloy::sol_types::private::Address, - ) -> alloy_contract::SolCallBuilder<&P, stakerStrategySharesCall, N> { - self.call_builder(&stakerStrategySharesCall { _0, _1 }) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummyPellStrategyManagerInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/dummy_se_bep20.rs b/crates/bindings/src/dummy_se_bep20.rs deleted file mode 100644 index 9feeef8ba..000000000 --- a/crates/bindings/src/dummy_se_bep20.rs +++ /dev/null @@ -1,5161 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface DummySeBep20 { - event Approval(address indexed owner, address indexed spender, uint256 value); - event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); - event Transfer(address indexed from, address indexed to, uint256 value); - - constructor(string name_, string symbol_, bool _doMint, bool _suppressMintError); - - 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 balanceOfUnderlying(address) external pure 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 mint(uint256) external pure returns (uint256); - function mintBehalf(address receiver, uint256 mintAmount) external returns (uint256); - function name() external view returns (string memory); - function owner() external view returns (address); - function redeem(uint256) external pure returns (uint256); - function renounceOwnership() external; - function sudoMint(address to, uint256 amount) external; - function symbol() external view returns (string memory); - function totalSupply() external view returns (uint256); - function transfer(address to, uint256 amount) external returns (bool); - function transferFrom(address from, address to, uint256 amount) external returns (bool); - function transferOwnership(address newOwner) external; -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "name_", - "type": "string", - "internalType": "string" - }, - { - "name": "symbol_", - "type": "string", - "internalType": "string" - }, - { - "name": "_doMint", - "type": "bool", - "internalType": "bool" - }, - { - "name": "_suppressMintError", - "type": "bool", - "internalType": "bool" - } - ], - "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": "balanceOfUnderlying", - "inputs": [ - { - "name": "", - "type": "address", - "internalType": "address" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "pure" - }, - { - "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": "mint", - "inputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "pure" - }, - { - "type": "function", - "name": "mintBehalf", - "inputs": [ - { - "name": "receiver", - "type": "address", - "internalType": "address" - }, - { - "name": "mintAmount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "name", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "string", - "internalType": "string" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "owner", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "address" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "redeem", - "inputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "pure" - }, - { - "type": "function", - "name": "renounceOwnership", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "sudoMint", - "inputs": [ - { - "name": "to", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "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": "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" - }, - { - "type": "function", - "name": "transferOwnership", - "inputs": [ - { - "name": "newOwner", - "type": "address", - "internalType": "address" - } - ], - "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": "OwnershipTransferred", - "inputs": [ - { - "name": "previousOwner", - "type": "address", - "indexed": true, - "internalType": "address" - }, - { - "name": "newOwner", - "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 DummySeBep20 { - use super::*; - use alloy::sol_types as 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__\xFD[P`@Qa\x11\x988\x03\x80a\x11\x98\x839\x81\x01`@\x81\x90Ra\0.\x91a\x01\xA2V[\x83\x83`\x03a\0<\x83\x82a\x02\xABV[P`\x04a\0I\x82\x82a\x02\xABV[PPPa\0ba\0]a\0\x9C` \x1B` \x1CV[a\0\xA0V[`\x05\x80Ta\xFF\xFF`\xA0\x1B\x19\x16`\x01`\xA0\x1B\x93\x15\x15\x93\x90\x93\x02`\xFF`\xA8\x1B\x19\x16\x92\x90\x92\x17`\x01`\xA8\x1B\x91\x15\x15\x91\x90\x91\x02\x17\x90UPa\x03e\x90PV[3\x90V[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x01`\x01`\xA0\x1B\x03\x19\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x82`\x1F\x83\x01\x12a\x01\x14W__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01-Wa\x01-a\0\xF1V[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x01[Wa\x01[a\0\xF1V[`@R\x81\x81R\x83\x82\x01` \x01\x85\x10\x15a\x01rW__\xFD[\x81` \x85\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[\x80Q\x80\x15\x15\x81\x14a\x01\x9DW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x01\xB5W__\xFD[\x84Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\xCAW__\xFD[a\x01\xD6\x87\x82\x88\x01a\x01\x05V[` \x87\x01Q\x90\x95P\x90P`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\xF3W__\xFD[a\x01\xFF\x87\x82\x88\x01a\x01\x05V[\x93PPa\x02\x0E`@\x86\x01a\x01\x8EV[\x91Pa\x02\x1C``\x86\x01a\x01\x8EV[\x90P\x92\x95\x91\x94P\x92PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x02;W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x02YWcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\x02\xA6W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x02\x84WP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x02\xA3W_\x81U`\x01\x01a\x02\x90V[PP[PPPV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x02\xC4Wa\x02\xC4a\0\xF1V[a\x02\xD8\x81a\x02\xD2\x84Ta\x02'V[\x84a\x02_V[` `\x1F\x82\x11`\x01\x81\x14a\x03\nW_\x83\x15a\x02\xF3WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x02\xA3V[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x039W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x03\x19V[P\x84\x82\x10\x15a\x03VW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[a\x0E&\x80a\x03r_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01IW_5`\xE0\x1C\x80cp\xA0\x821\x11a\0\xC7W\x80c\xA4W\xC2\xD7\x11a\0}W\x80c\xDB\0ju\x11a\0cW\x80c\xDB\0ju\x14a\x02cW\x80c\xDDb\xED>\x14a\x02\x97W\x80c\xF2\xFD\xE3\x8B\x14a\x02\xCFW__\xFD[\x80c\xA4W\xC2\xD7\x14a\x02qW\x80c\xA9\x05\x9C\xBB\x14a\x02\x84W__\xFD[\x80c\x8D\xA5\xCB[\x11a\0\xADW\x80c\x8D\xA5\xCB[\x14a\x02@W\x80c\x95\xD8\x9BA\x14a\x02[W\x80c\xA0q-h\x14a\x02cW__\xFD[\x80cp\xA0\x821\x14a\x02\x10W\x80cqP\x18\xA6\x14a\x028W__\xFD[\x80c#\xB8r\xDD\x11a\x01\x1CW\x80c1<\xE5g\x11a\x01\x02W\x80c1<\xE5g\x14a\x01\xDBW\x80c9P\x93Q\x14a\x01\xEAW\x80c:\xF9\xE6i\x14a\x01\xFDW__\xFD[\x80c#\xB8r\xDD\x14a\x01\xB3W\x80c-h\x8C\xA8\x14a\x01\xC6W__\xFD[\x80c\x06\xFD\xDE\x03\x14a\x01MW\x80c\t^\xA7\xB3\x14a\x01kW\x80c\x18\x16\r\xDD\x14a\x01\x8EW\x80c#2>\x03\x14a\x01\xA0W[__\xFD[a\x01Ua\x02\xE2V[`@Qa\x01b\x91\x90a\x0C/V[`@Q\x80\x91\x03\x90\xF3[a\x01~a\x01y6`\x04a\x0C\x9DV[a\x03rV[`@Q\x90\x15\x15\x81R` \x01a\x01bV[`\x02T[`@Q\x90\x81R` \x01a\x01bV[a\x01\x92a\x01\xAE6`\x04a\x0C\x9DV[a\x03\x8BV[a\x01~a\x01\xC16`\x04a\x0C\xC5V[a\x03\xF5V[a\x01\xD9a\x01\xD46`\x04a\x0C\x9DV[a\x04\x18V[\0[`@Q`\x12\x81R` \x01a\x01bV[a\x01~a\x01\xF86`\x04a\x0C\x9DV[a\x04\x85V[a\x01\x92a\x02\x0B6`\x04a\x0C\xFFV[P_\x90V[a\x01\x92a\x02\x1E6`\x04a\x0C\xFFV[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R` \x81\x90R`@\x90 T\x90V[a\x01\xD9a\x04\xC3V[`\x05T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01bV[a\x01Ua\x05(V[a\x01\x92a\x02\x0B6`\x04a\r\x1FV[a\x01~a\x02\x7F6`\x04a\x0C\x9DV[a\x057V[a\x01~a\x02\x926`\x04a\x0C\x9DV[a\x05\xE0V[a\x01\x92a\x02\xA56`\x04a\r6V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[a\x01\xD9a\x02\xDD6`\x04a\x0C\xFFV[a\x05\xEDV[```\x03\x80Ta\x02\xF1\x90a\rgV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\x1D\x90a\rgV[\x80\x15a\x03hW\x80`\x1F\x10a\x03?Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03hV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03KW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[_3a\x03\x7F\x81\x85\x85a\x06\xCFV[`\x01\x91PP[\x92\x91PPV[`\x05T_\x90u\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x03\xB8WP_a\x03\x85V[`\x05Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x03\xECWa\x03\xE5\x83\x83a\x08&V[P_a\x03\x85V[P`\x01\x92\x91PPV[_3a\x04\x02\x85\x82\x85a\t\x02V[a\x04\r\x85\x85\x85a\t\xB1V[P`\x01\x94\x93PPPPV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x04wW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x04\x81\x82\x82a\x08&V[PPV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90a\x03\x7F\x90\x82\x90\x86\x90a\x04\xBE\x90\x87\x90a\r\xB8V[a\x06\xCFV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x05\x1DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04nV[a\x05&_a\x0B\xC6V[V[```\x04\x80Ta\x02\xF1\x90a\rgV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90\x83\x81\x10\x15a\x05\xD3W`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[a\x04\r\x82\x86\x86\x84\x03a\x06\xCFV[_3a\x03\x7F\x81\x85\x85a\t\xB1V[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x06GW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04nV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x06\xC3W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01R\x7Fddress\0\0\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\x04nV[a\x06\xCC\x81a\x0B\xC6V[PV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x07JW`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x07\xC6W`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\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[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x08|W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FERC20: mint to the zero address\0`D\x82\x01R`d\x01a\x04nV[\x80`\x02_\x82\x82Ta\x08\x8D\x91\x90a\r\xB8V[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x83\x92\x90a\x08\xB9\x90\x84\x90a\r\xB8V[\x90\x91UPP`@Q\x81\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90_\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[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R 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\x81\x14a\t\xABW\x81\x81\x10\x15a\t\x9EW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FERC20: insufficient allowance\0\0\0`D\x82\x01R`d\x01a\x04nV[a\t\xAB\x84\x84\x84\x84\x03a\x06\xCFV[PPPPV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\n-W`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\n\xA9W`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R` \x81\x90R`@\x90 T\x81\x81\x10\x15a\x0B7W`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16_\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R\x90\x81 \x80T\x84\x92\x90a\x0Bm\x90\x84\x90a\r\xB8V[\x92PP\x81\x90UP\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\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\x0B\xB9\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3a\t\xABV[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\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\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\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\x84\x01\x01\x91PP\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0C\x98W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0C\xAEW__\xFD[a\x0C\xB7\x83a\x0C\x82V[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x0C\xD7W__\xFD[a\x0C\xE0\x84a\x0C\x82V[\x92Pa\x0C\xEE` \x85\x01a\x0C\x82V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\r\x0FW__\xFD[a\r\x18\x82a\x0C\x82V[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\r/W__\xFD[P5\x91\x90PV[__`@\x83\x85\x03\x12\x15a\rGW__\xFD[a\rP\x83a\x0C\x82V[\x91Pa\r^` \x84\x01a\x0C\x82V[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\r{W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\r\xB2W\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[P\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x03\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\xFE\xA2dipfsX\"\x12 ,O\x84\x9FL\x9E\x11!\n*\x99\xA0\x9C\xAA\x87\xD3\x9A\x93\xB9+\xE3\xD1\xD3\xB7\xA0\x8B\xF4(\x94\xEB\xE0'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\x01IW_5`\xE0\x1C\x80cp\xA0\x821\x11a\0\xC7W\x80c\xA4W\xC2\xD7\x11a\0}W\x80c\xDB\0ju\x11a\0cW\x80c\xDB\0ju\x14a\x02cW\x80c\xDDb\xED>\x14a\x02\x97W\x80c\xF2\xFD\xE3\x8B\x14a\x02\xCFW__\xFD[\x80c\xA4W\xC2\xD7\x14a\x02qW\x80c\xA9\x05\x9C\xBB\x14a\x02\x84W__\xFD[\x80c\x8D\xA5\xCB[\x11a\0\xADW\x80c\x8D\xA5\xCB[\x14a\x02@W\x80c\x95\xD8\x9BA\x14a\x02[W\x80c\xA0q-h\x14a\x02cW__\xFD[\x80cp\xA0\x821\x14a\x02\x10W\x80cqP\x18\xA6\x14a\x028W__\xFD[\x80c#\xB8r\xDD\x11a\x01\x1CW\x80c1<\xE5g\x11a\x01\x02W\x80c1<\xE5g\x14a\x01\xDBW\x80c9P\x93Q\x14a\x01\xEAW\x80c:\xF9\xE6i\x14a\x01\xFDW__\xFD[\x80c#\xB8r\xDD\x14a\x01\xB3W\x80c-h\x8C\xA8\x14a\x01\xC6W__\xFD[\x80c\x06\xFD\xDE\x03\x14a\x01MW\x80c\t^\xA7\xB3\x14a\x01kW\x80c\x18\x16\r\xDD\x14a\x01\x8EW\x80c#2>\x03\x14a\x01\xA0W[__\xFD[a\x01Ua\x02\xE2V[`@Qa\x01b\x91\x90a\x0C/V[`@Q\x80\x91\x03\x90\xF3[a\x01~a\x01y6`\x04a\x0C\x9DV[a\x03rV[`@Q\x90\x15\x15\x81R` \x01a\x01bV[`\x02T[`@Q\x90\x81R` \x01a\x01bV[a\x01\x92a\x01\xAE6`\x04a\x0C\x9DV[a\x03\x8BV[a\x01~a\x01\xC16`\x04a\x0C\xC5V[a\x03\xF5V[a\x01\xD9a\x01\xD46`\x04a\x0C\x9DV[a\x04\x18V[\0[`@Q`\x12\x81R` \x01a\x01bV[a\x01~a\x01\xF86`\x04a\x0C\x9DV[a\x04\x85V[a\x01\x92a\x02\x0B6`\x04a\x0C\xFFV[P_\x90V[a\x01\x92a\x02\x1E6`\x04a\x0C\xFFV[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R` \x81\x90R`@\x90 T\x90V[a\x01\xD9a\x04\xC3V[`\x05T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01bV[a\x01Ua\x05(V[a\x01\x92a\x02\x0B6`\x04a\r\x1FV[a\x01~a\x02\x7F6`\x04a\x0C\x9DV[a\x057V[a\x01~a\x02\x926`\x04a\x0C\x9DV[a\x05\xE0V[a\x01\x92a\x02\xA56`\x04a\r6V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[a\x01\xD9a\x02\xDD6`\x04a\x0C\xFFV[a\x05\xEDV[```\x03\x80Ta\x02\xF1\x90a\rgV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\x1D\x90a\rgV[\x80\x15a\x03hW\x80`\x1F\x10a\x03?Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03hV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03KW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[_3a\x03\x7F\x81\x85\x85a\x06\xCFV[`\x01\x91PP[\x92\x91PPV[`\x05T_\x90u\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x03\xB8WP_a\x03\x85V[`\x05Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x03\xECWa\x03\xE5\x83\x83a\x08&V[P_a\x03\x85V[P`\x01\x92\x91PPV[_3a\x04\x02\x85\x82\x85a\t\x02V[a\x04\r\x85\x85\x85a\t\xB1V[P`\x01\x94\x93PPPPV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x04wW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x04\x81\x82\x82a\x08&V[PPV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90a\x03\x7F\x90\x82\x90\x86\x90a\x04\xBE\x90\x87\x90a\r\xB8V[a\x06\xCFV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x05\x1DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04nV[a\x05&_a\x0B\xC6V[V[```\x04\x80Ta\x02\xF1\x90a\rgV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90\x83\x81\x10\x15a\x05\xD3W`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[a\x04\r\x82\x86\x86\x84\x03a\x06\xCFV[_3a\x03\x7F\x81\x85\x85a\t\xB1V[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x06GW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04nV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x06\xC3W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01R\x7Fddress\0\0\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\x04nV[a\x06\xCC\x81a\x0B\xC6V[PV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x07JW`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x07\xC6W`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\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[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x08|W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FERC20: mint to the zero address\0`D\x82\x01R`d\x01a\x04nV[\x80`\x02_\x82\x82Ta\x08\x8D\x91\x90a\r\xB8V[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x83\x92\x90a\x08\xB9\x90\x84\x90a\r\xB8V[\x90\x91UPP`@Q\x81\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90_\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[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R 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\x81\x14a\t\xABW\x81\x81\x10\x15a\t\x9EW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FERC20: insufficient allowance\0\0\0`D\x82\x01R`d\x01a\x04nV[a\t\xAB\x84\x84\x84\x84\x03a\x06\xCFV[PPPPV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\n-W`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\n\xA9W`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R` \x81\x90R`@\x90 T\x81\x81\x10\x15a\x0B7W`@QbF\x1B\xCD`\xE5\x1B\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\x04nV[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16_\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R\x90\x81 \x80T\x84\x92\x90a\x0Bm\x90\x84\x90a\r\xB8V[\x92PP\x81\x90UP\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\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\x0B\xB9\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3a\t\xABV[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\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\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\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\x84\x01\x01\x91PP\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0C\x98W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0C\xAEW__\xFD[a\x0C\xB7\x83a\x0C\x82V[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x0C\xD7W__\xFD[a\x0C\xE0\x84a\x0C\x82V[\x92Pa\x0C\xEE` \x85\x01a\x0C\x82V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\r\x0FW__\xFD[a\r\x18\x82a\x0C\x82V[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\r/W__\xFD[P5\x91\x90PV[__`@\x83\x85\x03\x12\x15a\rGW__\xFD[a\rP\x83a\x0C\x82V[\x91Pa\r^` \x84\x01a\x0C\x82V[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\r{W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\r\xB2W\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[P\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x03\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\xFE\xA2dipfsX\"\x12 ,O\x84\x9FL\x9E\x11!\n*\x99\xA0\x9C\xAA\x87\xD3\x9A\x93\xB9+\xE3\xD1\xD3\xB7\xA0\x8B\xF4(\x94\xEB\xE0'dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for Approval { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - 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, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - owner: topics.1, - spender: topics.2, - value: data.0, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.value), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = ::encode_topic( - &self.owner, - ); - out[2usize] = ::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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for OwnershipTransferred { - type DataTuple<'a> = (); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - 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, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - previousOwner: topics.1, - newOwner: topics.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return 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) -> ::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() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = ::encode_topic( - &self.previousOwner, - ); - out[2usize] = ::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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for Transfer { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - 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, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - from: topics.1, - to: topics.2, - value: data.0, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.value), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = ::encode_topic( - &self.from, - ); - out[2usize] = ::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_, bool _doMint, bool _suppressMintError); -```*/ - #[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, - #[allow(missing_docs)] - pub _doMint: bool, - #[allow(missing_docs)] - pub _suppressMintError: bool, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bool, - alloy::sol_types::sol_data::Bool, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::String, - bool, - bool, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value.name_, value.symbol_, value._doMint, value._suppressMintError) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - name_: tuple.0, - symbol_: tuple.1, - _doMint: tuple.2, - _suppressMintError: tuple.3, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolConstructor for constructorCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bool, - alloy::sol_types::sol_data::Bool, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.name_, - ), - ::tokenize( - &self.symbol_, - ), - ::tokenize( - &self._doMint, - ), - ::tokenize( - &self._suppressMintError, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: allowanceCall) -> Self { - (value.owner, value.spender) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for allowanceCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - owner: tuple.0, - spender: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: allowanceReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "allowance(address,address)"; - const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.owner, - ), - ::tokenize( - &self.spender, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: allowanceReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: approveCall) -> Self { - (value.spender, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for approveCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - spender: tuple.0, - amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: approveReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "approve(address,uint256)"; - const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.spender, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: approveReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: balanceOfCall) -> Self { - (value.account,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for balanceOfCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { account: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: balanceOfReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "balanceOf(address)"; - const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.account, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: balanceOfReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `balanceOfUnderlying(address)` and selector `0x3af9e669`. -```solidity -function balanceOfUnderlying(address) external pure returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct balanceOfUnderlyingCall(pub alloy::sol_types::private::Address); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`balanceOfUnderlying(address)`](balanceOfUnderlyingCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct balanceOfUnderlyingReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: balanceOfUnderlyingCall) -> Self { - (value.0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for balanceOfUnderlyingCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self(tuple.0) - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: balanceOfUnderlyingReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for balanceOfUnderlyingReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for balanceOfUnderlyingCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "balanceOfUnderlying(address)"; - const SELECTOR: [u8; 4] = [58u8, 249u8, 230u8, 105u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.0, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: balanceOfUnderlyingReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: balanceOfUnderlyingReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: decimalsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for decimalsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: decimalsReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for decimalsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for decimalsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = u8; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "decimals()"; - const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: decimalsReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: decreaseAllowanceCall) -> Self { - (value.spender, value.subtractedValue) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for decreaseAllowanceCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - spender: tuple.0, - subtractedValue: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: decreaseAllowanceReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)"; - const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.spender, - ), - as alloy_sol_types::SolType>::tokenize(&self.subtractedValue), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: decreaseAllowanceReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: increaseAllowanceCall) -> Self { - (value.spender, value.addedValue) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for increaseAllowanceCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - spender: tuple.0, - addedValue: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: increaseAllowanceReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "increaseAllowance(address,uint256)"; - const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.spender, - ), - as alloy_sol_types::SolType>::tokenize(&self.addedValue), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: increaseAllowanceReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `mint(uint256)` and selector `0xa0712d68`. -```solidity -function mint(uint256) external pure returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct mintCall(pub alloy::sol_types::private::primitives::aliases::U256); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`mint(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: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: mintCall) -> Self { - (value.0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for mintCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self(tuple.0) - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: mintReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "mint(uint256)"; - const SELECTOR: [u8; 4] = [160u8, 113u8, 45u8, 104u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.0), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: mintReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `mintBehalf(address,uint256)` and selector `0x23323e03`. -```solidity -function mintBehalf(address receiver, uint256 mintAmount) external returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct mintBehalfCall { - #[allow(missing_docs)] - pub receiver: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub mintAmount: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`mintBehalf(address,uint256)`](mintBehalfCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct mintBehalfReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: mintBehalfCall) -> Self { - (value.receiver, value.mintAmount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for mintBehalfCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - receiver: tuple.0, - mintAmount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: mintBehalfReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for mintBehalfReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for mintBehalfCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "mintBehalf(address,uint256)"; - const SELECTOR: [u8; 4] = [35u8, 50u8, 62u8, 3u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.receiver, - ), - as alloy_sol_types::SolType>::tokenize(&self.mintAmount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: mintBehalfReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: mintBehalfReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: nameCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for nameCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: nameReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for nameReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for nameCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::String; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "name()"; - const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: nameReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: ownerCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for ownerCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: ownerReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for ownerReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for ownerCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "owner()"; - const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: ownerReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `redeem(uint256)` and selector `0xdb006a75`. -```solidity -function redeem(uint256) external pure returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct redeemCall(pub alloy::sol_types::private::primitives::aliases::U256); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`redeem(uint256)`](redeemCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct redeemReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: redeemCall) -> Self { - (value.0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for redeemCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self(tuple.0) - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: redeemReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for redeemReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for redeemCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "redeem(uint256)"; - const SELECTOR: [u8; 4] = [219u8, 0u8, 106u8, 117u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.0), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: redeemReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: redeemReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: renounceOwnershipCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for renounceOwnershipCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: renounceOwnershipReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for renounceOwnershipReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl renounceOwnershipReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for renounceOwnershipCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = renounceOwnershipReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "renounceOwnership()"; - const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8]; - #[inline] - fn new<'a>( - tuple: 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 { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `sudoMint(address,uint256)` and selector `0x2d688ca8`. -```solidity -function sudoMint(address to, uint256 amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct sudoMintCall { - #[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 [`sudoMint(address,uint256)`](sudoMintCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct sudoMintReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: sudoMintCall) -> Self { - (value.to, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for sudoMintCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - to: tuple.0, - amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: sudoMintReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for sudoMintReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl sudoMintReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for sudoMintCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = sudoMintReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "sudoMint(address,uint256)"; - const SELECTOR: [u8; 4] = [45u8, 104u8, 140u8, 168u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.to, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - sudoMintReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: symbolCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for symbolCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: symbolReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for symbolReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for symbolCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::String; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "symbol()"; - const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: symbolReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: totalSupplyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for totalSupplyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: totalSupplyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for totalSupplyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for totalSupplyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "totalSupply()"; - const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: totalSupplyReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferCall) -> Self { - (value.to, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for transferCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - to: tuple.0, - amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "transfer(address,uint256)"; - const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.to, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: transferReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferFromCall) -> Self { - (value.from, value.to, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for transferFromCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - from: tuple.0, - to: tuple.1, - amount: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferFromReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "transferFrom(address,address,uint256)"; - const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.from, - ), - ::tokenize( - &self.to, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: transferFromReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: transferOwnershipCall) -> Self { - (value.newOwner,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for transferOwnershipCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { newOwner: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: transferOwnershipReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for transferOwnershipReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl transferOwnershipReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for transferOwnershipCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = transferOwnershipReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "transferOwnership(address)"; - const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::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 { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`DummySeBep20`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum DummySeBep20Calls { - #[allow(missing_docs)] - allowance(allowanceCall), - #[allow(missing_docs)] - approve(approveCall), - #[allow(missing_docs)] - balanceOf(balanceOfCall), - #[allow(missing_docs)] - balanceOfUnderlying(balanceOfUnderlyingCall), - #[allow(missing_docs)] - decimals(decimalsCall), - #[allow(missing_docs)] - decreaseAllowance(decreaseAllowanceCall), - #[allow(missing_docs)] - increaseAllowance(increaseAllowanceCall), - #[allow(missing_docs)] - mint(mintCall), - #[allow(missing_docs)] - mintBehalf(mintBehalfCall), - #[allow(missing_docs)] - name(nameCall), - #[allow(missing_docs)] - owner(ownerCall), - #[allow(missing_docs)] - redeem(redeemCall), - #[allow(missing_docs)] - renounceOwnership(renounceOwnershipCall), - #[allow(missing_docs)] - sudoMint(sudoMintCall), - #[allow(missing_docs)] - symbol(symbolCall), - #[allow(missing_docs)] - totalSupply(totalSupplyCall), - #[allow(missing_docs)] - transfer(transferCall), - #[allow(missing_docs)] - transferFrom(transferFromCall), - #[allow(missing_docs)] - transferOwnership(transferOwnershipCall), - } - #[automatically_derived] - impl DummySeBep20Calls { - /// 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, 50u8, 62u8, 3u8], - [35u8, 184u8, 114u8, 221u8], - [45u8, 104u8, 140u8, 168u8], - [49u8, 60u8, 229u8, 103u8], - [57u8, 80u8, 147u8, 81u8], - [58u8, 249u8, 230u8, 105u8], - [112u8, 160u8, 130u8, 49u8], - [113u8, 80u8, 24u8, 166u8], - [141u8, 165u8, 203u8, 91u8], - [149u8, 216u8, 155u8, 65u8], - [160u8, 113u8, 45u8, 104u8], - [164u8, 87u8, 194u8, 215u8], - [169u8, 5u8, 156u8, 187u8], - [219u8, 0u8, 106u8, 117u8], - [221u8, 98u8, 237u8, 62u8], - [242u8, 253u8, 227u8, 139u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for DummySeBep20Calls { - const NAME: &'static str = "DummySeBep20Calls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 19usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::allowance(_) => { - ::SELECTOR - } - Self::approve(_) => ::SELECTOR, - Self::balanceOf(_) => { - ::SELECTOR - } - Self::balanceOfUnderlying(_) => { - ::SELECTOR - } - Self::decimals(_) => ::SELECTOR, - Self::decreaseAllowance(_) => { - ::SELECTOR - } - Self::increaseAllowance(_) => { - ::SELECTOR - } - Self::mint(_) => ::SELECTOR, - Self::mintBehalf(_) => { - ::SELECTOR - } - Self::name(_) => ::SELECTOR, - Self::owner(_) => ::SELECTOR, - Self::redeem(_) => ::SELECTOR, - Self::renounceOwnership(_) => { - ::SELECTOR - } - Self::sudoMint(_) => ::SELECTOR, - Self::symbol(_) => ::SELECTOR, - Self::totalSupply(_) => { - ::SELECTOR - } - Self::transfer(_) => ::SELECTOR, - Self::transferFrom(_) => { - ::SELECTOR - } - Self::transferOwnership(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn name(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummySeBep20Calls::name) - } - name - }, - { - fn approve( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummySeBep20Calls::approve) - } - approve - }, - { - fn totalSupply( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummySeBep20Calls::totalSupply) - } - totalSupply - }, - { - fn mintBehalf( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummySeBep20Calls::mintBehalf) - } - mintBehalf - }, - { - fn transferFrom( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummySeBep20Calls::transferFrom) - } - transferFrom - }, - { - fn sudoMint( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummySeBep20Calls::sudoMint) - } - sudoMint - }, - { - fn decimals( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummySeBep20Calls::decimals) - } - decimals - }, - { - fn increaseAllowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummySeBep20Calls::increaseAllowance) - } - increaseAllowance - }, - { - fn balanceOfUnderlying( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummySeBep20Calls::balanceOfUnderlying) - } - balanceOfUnderlying - }, - { - fn balanceOf( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummySeBep20Calls::balanceOf) - } - balanceOf - }, - { - fn renounceOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummySeBep20Calls::renounceOwnership) - } - renounceOwnership - }, - { - fn owner(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummySeBep20Calls::owner) - } - owner - }, - { - fn symbol( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummySeBep20Calls::symbol) - } - symbol - }, - { - fn mint(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummySeBep20Calls::mint) - } - mint - }, - { - fn decreaseAllowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummySeBep20Calls::decreaseAllowance) - } - decreaseAllowance - }, - { - fn transfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummySeBep20Calls::transfer) - } - transfer - }, - { - fn redeem( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummySeBep20Calls::redeem) - } - redeem - }, - { - fn allowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummySeBep20Calls::allowance) - } - allowance - }, - { - fn transferOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummySeBep20Calls::transferOwnership) - } - transferOwnership - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn name(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummySeBep20Calls::name) - } - name - }, - { - fn approve( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummySeBep20Calls::approve) - } - approve - }, - { - fn totalSupply( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummySeBep20Calls::totalSupply) - } - totalSupply - }, - { - fn mintBehalf( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummySeBep20Calls::mintBehalf) - } - mintBehalf - }, - { - fn transferFrom( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummySeBep20Calls::transferFrom) - } - transferFrom - }, - { - fn sudoMint( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummySeBep20Calls::sudoMint) - } - sudoMint - }, - { - fn decimals( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummySeBep20Calls::decimals) - } - decimals - }, - { - fn increaseAllowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummySeBep20Calls::increaseAllowance) - } - increaseAllowance - }, - { - fn balanceOfUnderlying( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummySeBep20Calls::balanceOfUnderlying) - } - balanceOfUnderlying - }, - { - fn balanceOf( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummySeBep20Calls::balanceOf) - } - balanceOf - }, - { - fn renounceOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummySeBep20Calls::renounceOwnership) - } - renounceOwnership - }, - { - fn owner(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummySeBep20Calls::owner) - } - owner - }, - { - fn symbol( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummySeBep20Calls::symbol) - } - symbol - }, - { - fn mint(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummySeBep20Calls::mint) - } - mint - }, - { - fn decreaseAllowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummySeBep20Calls::decreaseAllowance) - } - decreaseAllowance - }, - { - fn transfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummySeBep20Calls::transfer) - } - transfer - }, - { - fn redeem( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummySeBep20Calls::redeem) - } - redeem - }, - { - fn allowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummySeBep20Calls::allowance) - } - allowance - }, - { - fn transferOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummySeBep20Calls::transferOwnership) - } - transferOwnership - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::allowance(inner) => { - ::abi_encoded_size(inner) - } - Self::approve(inner) => { - ::abi_encoded_size(inner) - } - Self::balanceOf(inner) => { - ::abi_encoded_size(inner) - } - Self::balanceOfUnderlying(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::decimals(inner) => { - ::abi_encoded_size(inner) - } - Self::decreaseAllowance(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::increaseAllowance(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::mint(inner) => { - ::abi_encoded_size(inner) - } - Self::mintBehalf(inner) => { - ::abi_encoded_size(inner) - } - Self::name(inner) => { - ::abi_encoded_size(inner) - } - Self::owner(inner) => { - ::abi_encoded_size(inner) - } - Self::redeem(inner) => { - ::abi_encoded_size(inner) - } - Self::renounceOwnership(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::sudoMint(inner) => { - ::abi_encoded_size(inner) - } - Self::symbol(inner) => { - ::abi_encoded_size(inner) - } - Self::totalSupply(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::transfer(inner) => { - ::abi_encoded_size(inner) - } - Self::transferFrom(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::transferOwnership(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::allowance(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::approve(inner) => { - ::abi_encode_raw(inner, out) - } - Self::balanceOf(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::balanceOfUnderlying(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::decimals(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::decreaseAllowance(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::increaseAllowance(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::mint(inner) => { - ::abi_encode_raw(inner, out) - } - Self::mintBehalf(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::name(inner) => { - ::abi_encode_raw(inner, out) - } - Self::owner(inner) => { - ::abi_encode_raw(inner, out) - } - Self::redeem(inner) => { - ::abi_encode_raw(inner, out) - } - Self::renounceOwnership(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::sudoMint(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::symbol(inner) => { - ::abi_encode_raw(inner, out) - } - Self::totalSupply(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::transfer(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::transferFrom(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::transferOwnership(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`DummySeBep20`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum DummySeBep20Events { - #[allow(missing_docs)] - Approval(Approval), - #[allow(missing_docs)] - OwnershipTransferred(OwnershipTransferred), - #[allow(missing_docs)] - Transfer(Transfer), - } - #[automatically_derived] - impl DummySeBep20Events { - /// 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]] = &[ - [ - 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, 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, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for DummySeBep20Events { - const NAME: &'static str = "DummySeBep20Events"; - const COUNT: usize = 3usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::Approval) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::OwnershipTransferred) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::Transfer) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 DummySeBep20Events { - 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::OwnershipTransferred(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::OwnershipTransferred(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 as alloy_contract; - /**Creates a new wrapper around an on-chain [`DummySeBep20`](self) contract instance. - -See the [wrapper's documentation](`DummySeBep20Instance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> DummySeBep20Instance { - DummySeBep20Instance::::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: alloy_contract::private::Network, - >( - provider: P, - name_: alloy::sol_types::private::String, - symbol_: alloy::sol_types::private::String, - _doMint: bool, - _suppressMintError: bool, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - DummySeBep20Instance::< - P, - N, - >::deploy(provider, name_, symbol_, _doMint, _suppressMintError) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - name_: alloy::sol_types::private::String, - symbol_: alloy::sol_types::private::String, - _doMint: bool, - _suppressMintError: bool, - ) -> alloy_contract::RawCallBuilder { - DummySeBep20Instance::< - P, - N, - >::deploy_builder(provider, name_, symbol_, _doMint, _suppressMintError) - } - /**A [`DummySeBep20`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`DummySeBep20`](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 DummySeBep20Instance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for DummySeBep20Instance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("DummySeBep20Instance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummySeBep20Instance { - /**Creates a new wrapper around an on-chain [`DummySeBep20`](self) contract instance. - -See the [wrapper's documentation](`DummySeBep20Instance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - name_: alloy::sol_types::private::String, - symbol_: alloy::sol_types::private::String, - _doMint: bool, - _suppressMintError: bool, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder( - provider, - name_, - symbol_, - _doMint, - _suppressMintError, - ); - 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, - name_: alloy::sol_types::private::String, - symbol_: alloy::sol_types::private::String, - _doMint: bool, - _suppressMintError: bool, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { - name_, - symbol_, - _doMint, - _suppressMintError, - }, - )[..], - ] - .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 DummySeBep20Instance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> DummySeBep20Instance { - DummySeBep20Instance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummySeBep20Instance { - /// 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( - &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 [`balanceOfUnderlying`] function. - pub fn balanceOfUnderlying( - &self, - _0: alloy::sol_types::private::Address, - ) -> alloy_contract::SolCallBuilder<&P, balanceOfUnderlyingCall, N> { - self.call_builder(&balanceOfUnderlyingCall(_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 [`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 [`mint`] function. - pub fn mint( - &self, - _0: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> { - self.call_builder(&mintCall(_0)) - } - ///Creates a new call builder for the [`mintBehalf`] function. - pub fn mintBehalf( - &self, - receiver: alloy::sol_types::private::Address, - mintAmount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, mintBehalfCall, N> { - self.call_builder( - &mintBehalfCall { - receiver, - mintAmount, - }, - ) - } - ///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 [`redeem`] function. - pub fn redeem( - &self, - _0: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, redeemCall, N> { - self.call_builder(&redeemCall(_0)) - } - ///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 [`sudoMint`] function. - pub fn sudoMint( - &self, - to: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, sudoMintCall, N> { - self.call_builder(&sudoMintCall { to, amount }) - } - ///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, - 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, - }, - ) - } - ///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. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummySeBep20Instance { - /// 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( - &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::() - } - ///Creates a new event filter for the [`OwnershipTransferred`] event. - pub fn OwnershipTransferred_filter( - &self, - ) -> alloy_contract::Event<&P, OwnershipTransferred, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`Transfer`] event. - pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/dummy_shoe_bill_token.rs b/crates/bindings/src/dummy_shoe_bill_token.rs deleted file mode 100644 index e6811d659..000000000 --- a/crates/bindings/src/dummy_shoe_bill_token.rs +++ /dev/null @@ -1,4696 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface DummyShoeBillToken { - event Approval(address indexed owner, address indexed spender, uint256 value); - event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); - event Transfer(address indexed from, address indexed to, uint256 value); - - constructor(string name_, string symbol_, bool _doMint); - - 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 balanceOfUnderlying(address) external pure 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 mint(uint256 mintAmount) external returns (uint256); - function name() external view returns (string memory); - function owner() external view returns (address); - function renounceOwnership() external; - function sudoMint(address to, uint256 amount) external; - function symbol() external view returns (string memory); - function totalSupply() external view returns (uint256); - function transfer(address to, uint256 amount) external returns (bool); - function transferFrom(address from, address to, uint256 amount) external returns (bool); - function transferOwnership(address newOwner) external; -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "name_", - "type": "string", - "internalType": "string" - }, - { - "name": "symbol_", - "type": "string", - "internalType": "string" - }, - { - "name": "_doMint", - "type": "bool", - "internalType": "bool" - } - ], - "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": "balanceOfUnderlying", - "inputs": [ - { - "name": "", - "type": "address", - "internalType": "address" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "pure" - }, - { - "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": "mint", - "inputs": [ - { - "name": "mintAmount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "name", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "string", - "internalType": "string" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "owner", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "address" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "renounceOwnership", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "sudoMint", - "inputs": [ - { - "name": "to", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "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": "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" - }, - { - "type": "function", - "name": "transferOwnership", - "inputs": [ - { - "name": "newOwner", - "type": "address", - "internalType": "address" - } - ], - "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": "OwnershipTransferred", - "inputs": [ - { - "name": "previousOwner", - "type": "address", - "indexed": true, - "internalType": "address" - }, - { - "name": "newOwner", - "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 DummyShoeBillToken { - use super::*; - use alloy::sol_types as 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__\xFD[P`@Qa\x10\xF78\x03\x80a\x10\xF7\x839\x81\x01`@\x81\x90Ra\0.\x91a\x01xV[\x82\x82`\x03a\0<\x83\x82a\x02xV[P`\x04a\0I\x82\x82a\x02xV[PPPa\0ba\0]a\0\x86` \x1B` \x1CV[a\0\x8AV[`\x05\x80T\x91\x15\x15`\x01`\xA0\x1B\x02`\xFF`\xA0\x1B\x19\x90\x92\x16\x91\x90\x91\x17\x90UPa\x032\x90PV[3\x90V[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x01`\x01`\xA0\x1B\x03\x19\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x82`\x1F\x83\x01\x12a\0\xFEW__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\x17Wa\x01\x17a\0\xDBV[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x01EWa\x01Ea\0\xDBV[`@R\x81\x81R\x83\x82\x01` \x01\x85\x10\x15a\x01\\W__\xFD[\x81` \x85\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[___``\x84\x86\x03\x12\x15a\x01\x8AW__\xFD[\x83Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\x9FW__\xFD[a\x01\xAB\x86\x82\x87\x01a\0\xEFV[` \x86\x01Q\x90\x94P\x90P`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\xC8W__\xFD[a\x01\xD4\x86\x82\x87\x01a\0\xEFV[\x92PP`@\x84\x01Q\x80\x15\x15\x81\x14a\x01\xE9W__\xFD[\x80\x91PP\x92P\x92P\x92V[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x02\x08W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x02&WcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\x02sW\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x02QWP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x02pW_\x81U`\x01\x01a\x02]V[PP[PPPV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x02\x91Wa\x02\x91a\0\xDBV[a\x02\xA5\x81a\x02\x9F\x84Ta\x01\xF4V[\x84a\x02,V[` `\x1F\x82\x11`\x01\x81\x14a\x02\xD7W_\x83\x15a\x02\xC0WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x02pV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x03\x06W\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x02\xE6V[P\x84\x82\x10\x15a\x03#W\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[a\r\xB8\x80a\x03?_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80cp\xA0\x821\x11a\0\xADW\x80c\xA0q-h\x11a\0}W\x80c\xA9\x05\x9C\xBB\x11a\0cW\x80c\xA9\x05\x9C\xBB\x14a\x02BW\x80c\xDDb\xED>\x14a\x02UW\x80c\xF2\xFD\xE3\x8B\x14a\x02\x8DW__\xFD[\x80c\xA0q-h\x14a\x02\x1CW\x80c\xA4W\xC2\xD7\x14a\x02/W__\xFD[\x80cp\xA0\x821\x14a\x01\xC9W\x80cqP\x18\xA6\x14a\x01\xF1W\x80c\x8D\xA5\xCB[\x14a\x01\xF9W\x80c\x95\xD8\x9BA\x14a\x02\x14W__\xFD[\x80c-h\x8C\xA8\x11a\0\xE8W\x80c-h\x8C\xA8\x14a\x01\x7FW\x80c1<\xE5g\x14a\x01\x94W\x80c9P\x93Q\x14a\x01\xA3W\x80c:\xF9\xE6i\x14a\x01\xB6W__\xFD[\x80c\x06\xFD\xDE\x03\x14a\x01\x19W\x80c\t^\xA7\xB3\x14a\x017W\x80c\x18\x16\r\xDD\x14a\x01ZW\x80c#\xB8r\xDD\x14a\x01lW[__\xFD[a\x01!a\x02\xA0V[`@Qa\x01.\x91\x90a\x0B\xC1V[`@Q\x80\x91\x03\x90\xF3[a\x01Ja\x01E6`\x04a\x0C/V[a\x030V[`@Q\x90\x15\x15\x81R` \x01a\x01.V[`\x02T[`@Q\x90\x81R` \x01a\x01.V[a\x01Ja\x01z6`\x04a\x0CWV[a\x03IV[a\x01\x92a\x01\x8D6`\x04a\x0C/V[a\x03lV[\0[`@Q`\x12\x81R` \x01a\x01.V[a\x01Ja\x01\xB16`\x04a\x0C/V[a\x03\xD9V[a\x01^a\x01\xC46`\x04a\x0C\x91V[P_\x90V[a\x01^a\x01\xD76`\x04a\x0C\x91V[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R` \x81\x90R`@\x90 T\x90V[a\x01\x92a\x04\x17V[`\x05T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01.V[a\x01!a\x04|V[a\x01^a\x02*6`\x04a\x0C\xB1V[a\x04\x8BV[a\x01Ja\x02=6`\x04a\x0C/V[a\x04\xC9V[a\x01Ja\x02P6`\x04a\x0C/V[a\x05rV[a\x01^a\x02c6`\x04a\x0C\xC8V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[a\x01\x92a\x02\x9B6`\x04a\x0C\x91V[a\x05\x7FV[```\x03\x80Ta\x02\xAF\x90a\x0C\xF9V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\xDB\x90a\x0C\xF9V[\x80\x15a\x03&W\x80`\x1F\x10a\x02\xFDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03&V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\tW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[_3a\x03=\x81\x85\x85a\x06aV[`\x01\x91PP[\x92\x91PPV[_3a\x03V\x85\x82\x85a\x07\xB8V[a\x03a\x85\x85\x85a\x08gV[P`\x01\x94\x93PPPPV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x03\xCBW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\xD5\x82\x82a\n|V[PPV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90a\x03=\x90\x82\x90\x86\x90a\x04\x12\x90\x87\x90a\rJV[a\x06aV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x04qW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03\xC2V[a\x04z_a\x0BXV[V[```\x04\x80Ta\x02\xAF\x90a\x0C\xF9V[`\x05T_\x90t\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x04\xC1Wa\x04\xBA3\x83a\n|V[P_\x91\x90PV[P`\x01\x91\x90PV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90\x83\x81\x10\x15a\x05eW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[a\x03a\x82\x86\x86\x84\x03a\x06aV[_3a\x03=\x81\x85\x85a\x08gV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x05\xD9W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x06UW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01R\x7Fddress\0\0\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\x03\xC2V[a\x06^\x81a\x0BXV[PV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x06\xDCW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x07XW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\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[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R 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\x81\x14a\x08aW\x81\x81\x10\x15a\x08TW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FERC20: insufficient allowance\0\0\0`D\x82\x01R`d\x01a\x03\xC2V[a\x08a\x84\x84\x84\x84\x03a\x06aV[PPPPV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x08\xE3W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\t_W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R` \x81\x90R`@\x90 T\x81\x81\x10\x15a\t\xEDW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16_\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R\x90\x81 \x80T\x84\x92\x90a\n#\x90\x84\x90a\rJV[\x92PP\x81\x90UP\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\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\no\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3a\x08aV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\n\xD2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FERC20: mint to the zero address\0`D\x82\x01R`d\x01a\x03\xC2V[\x80`\x02_\x82\x82Ta\n\xE3\x91\x90a\rJV[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x83\x92\x90a\x0B\x0F\x90\x84\x90a\rJV[\x90\x91UPP`@Q\x81\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90_\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[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\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\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\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\x84\x01\x01\x91PP\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0C*W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0C@W__\xFD[a\x0CI\x83a\x0C\x14V[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x0CiW__\xFD[a\x0Cr\x84a\x0C\x14V[\x92Pa\x0C\x80` \x85\x01a\x0C\x14V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\x0C\xA1W__\xFD[a\x0C\xAA\x82a\x0C\x14V[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x0C\xC1W__\xFD[P5\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0C\xD9W__\xFD[a\x0C\xE2\x83a\x0C\x14V[\x91Pa\x0C\xF0` \x84\x01a\x0C\x14V[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\r\rW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\rDW\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[P\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x03CW\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\xFE\xA2dipfsX\"\x12 \x17Cd\xA8T\x11<\x1Bx1\xA6\xAB\x98\xF3%B\xD3\xA3\xB5PLB1\xF7\xE1\xA0\x8BU^_\x9FmdsolcC\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\x01\x15W_5`\xE0\x1C\x80cp\xA0\x821\x11a\0\xADW\x80c\xA0q-h\x11a\0}W\x80c\xA9\x05\x9C\xBB\x11a\0cW\x80c\xA9\x05\x9C\xBB\x14a\x02BW\x80c\xDDb\xED>\x14a\x02UW\x80c\xF2\xFD\xE3\x8B\x14a\x02\x8DW__\xFD[\x80c\xA0q-h\x14a\x02\x1CW\x80c\xA4W\xC2\xD7\x14a\x02/W__\xFD[\x80cp\xA0\x821\x14a\x01\xC9W\x80cqP\x18\xA6\x14a\x01\xF1W\x80c\x8D\xA5\xCB[\x14a\x01\xF9W\x80c\x95\xD8\x9BA\x14a\x02\x14W__\xFD[\x80c-h\x8C\xA8\x11a\0\xE8W\x80c-h\x8C\xA8\x14a\x01\x7FW\x80c1<\xE5g\x14a\x01\x94W\x80c9P\x93Q\x14a\x01\xA3W\x80c:\xF9\xE6i\x14a\x01\xB6W__\xFD[\x80c\x06\xFD\xDE\x03\x14a\x01\x19W\x80c\t^\xA7\xB3\x14a\x017W\x80c\x18\x16\r\xDD\x14a\x01ZW\x80c#\xB8r\xDD\x14a\x01lW[__\xFD[a\x01!a\x02\xA0V[`@Qa\x01.\x91\x90a\x0B\xC1V[`@Q\x80\x91\x03\x90\xF3[a\x01Ja\x01E6`\x04a\x0C/V[a\x030V[`@Q\x90\x15\x15\x81R` \x01a\x01.V[`\x02T[`@Q\x90\x81R` \x01a\x01.V[a\x01Ja\x01z6`\x04a\x0CWV[a\x03IV[a\x01\x92a\x01\x8D6`\x04a\x0C/V[a\x03lV[\0[`@Q`\x12\x81R` \x01a\x01.V[a\x01Ja\x01\xB16`\x04a\x0C/V[a\x03\xD9V[a\x01^a\x01\xC46`\x04a\x0C\x91V[P_\x90V[a\x01^a\x01\xD76`\x04a\x0C\x91V[`\x01`\x01`\xA0\x1B\x03\x16_\x90\x81R` \x81\x90R`@\x90 T\x90V[a\x01\x92a\x04\x17V[`\x05T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01.V[a\x01!a\x04|V[a\x01^a\x02*6`\x04a\x0C\xB1V[a\x04\x8BV[a\x01Ja\x02=6`\x04a\x0C/V[a\x04\xC9V[a\x01Ja\x02P6`\x04a\x0C/V[a\x05rV[a\x01^a\x02c6`\x04a\x0C\xC8V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[a\x01\x92a\x02\x9B6`\x04a\x0C\x91V[a\x05\x7FV[```\x03\x80Ta\x02\xAF\x90a\x0C\xF9V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x02\xDB\x90a\x0C\xF9V[\x80\x15a\x03&W\x80`\x1F\x10a\x02\xFDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03&V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\tW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[_3a\x03=\x81\x85\x85a\x06aV[`\x01\x91PP[\x92\x91PPV[_3a\x03V\x85\x82\x85a\x07\xB8V[a\x03a\x85\x85\x85a\x08gV[P`\x01\x94\x93PPPPV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x03\xCBW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\xD5\x82\x82a\n|V[PPV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90a\x03=\x90\x82\x90\x86\x90a\x04\x12\x90\x87\x90a\rJV[a\x06aV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x04qW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03\xC2V[a\x04z_a\x0BXV[V[```\x04\x80Ta\x02\xAF\x90a\x0C\xF9V[`\x05T_\x90t\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x04\xC1Wa\x04\xBA3\x83a\n|V[P_\x91\x90PV[P`\x01\x91\x90PV[3_\x81\x81R`\x01` \x90\x81R`@\x80\x83 `\x01`\x01`\xA0\x1B\x03\x87\x16\x84R\x90\x91R\x81 T\x90\x91\x90\x83\x81\x10\x15a\x05eW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[a\x03a\x82\x86\x86\x84\x03a\x06aV[_3a\x03=\x81\x85\x85a\x08gV[`\x05T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x05\xD9W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x06UW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01R\x7Fddress\0\0\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\x03\xC2V[a\x06^\x81a\x0BXV[PV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x06\xDCW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x07XW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\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[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R 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\x81\x14a\x08aW\x81\x81\x10\x15a\x08TW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FERC20: insufficient allowance\0\0\0`D\x82\x01R`d\x01a\x03\xC2V[a\x08a\x84\x84\x84\x84\x03a\x06aV[PPPPV[`\x01`\x01`\xA0\x1B\x03\x83\x16a\x08\xE3W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\t_W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R` \x81\x90R`@\x90 T\x81\x81\x10\x15a\t\xEDW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC2V[`\x01`\x01`\xA0\x1B\x03\x80\x85\x16_\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R\x90\x81 \x80T\x84\x92\x90a\n#\x90\x84\x90a\rJV[\x92PP\x81\x90UP\x82`\x01`\x01`\xA0\x1B\x03\x16\x84`\x01`\x01`\xA0\x1B\x03\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\no\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3a\x08aV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\n\xD2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FERC20: mint to the zero address\0`D\x82\x01R`d\x01a\x03\xC2V[\x80`\x02_\x82\x82Ta\n\xE3\x91\x90a\rJV[\x90\x91UPP`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R` \x81\x90R`@\x81 \x80T\x83\x92\x90a\x0B\x0F\x90\x84\x90a\rJV[\x90\x91UPP`@Q\x81\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90_\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[`\x05\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\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\x83\x16\x81\x17\x90\x93U`@Q\x91\x16\x91\x90\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\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\x84\x01\x01\x91PP\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0C*W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0C@W__\xFD[a\x0CI\x83a\x0C\x14V[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\x0CiW__\xFD[a\x0Cr\x84a\x0C\x14V[\x92Pa\x0C\x80` \x85\x01a\x0C\x14V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\x0C\xA1W__\xFD[a\x0C\xAA\x82a\x0C\x14V[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x0C\xC1W__\xFD[P5\x91\x90PV[__`@\x83\x85\x03\x12\x15a\x0C\xD9W__\xFD[a\x0C\xE2\x83a\x0C\x14V[\x91Pa\x0C\xF0` \x84\x01a\x0C\x14V[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\r\rW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\rDW\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[P\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x03CW\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\xFE\xA2dipfsX\"\x12 \x17Cd\xA8T\x11<\x1Bx1\xA6\xAB\x98\xF3%B\xD3\xA3\xB5PLB1\xF7\xE1\xA0\x8BU^_\x9FmdsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for Approval { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - 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, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - owner: topics.1, - spender: topics.2, - value: data.0, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.value), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = ::encode_topic( - &self.owner, - ); - out[2usize] = ::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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for OwnershipTransferred { - type DataTuple<'a> = (); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - 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, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - previousOwner: topics.1, - newOwner: topics.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return 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) -> ::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() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = ::encode_topic( - &self.previousOwner, - ); - out[2usize] = ::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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for Transfer { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - 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, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - from: topics.1, - to: topics.2, - value: data.0, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.value), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = ::encode_topic( - &self.from, - ); - out[2usize] = ::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_, bool _doMint); -```*/ - #[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, - #[allow(missing_docs)] - pub _doMint: bool, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bool, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::String, - bool, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value.name_, value.symbol_, value._doMint) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - name_: tuple.0, - symbol_: tuple.1, - _doMint: tuple.2, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolConstructor for constructorCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bool, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.name_, - ), - ::tokenize( - &self.symbol_, - ), - ::tokenize( - &self._doMint, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: allowanceCall) -> Self { - (value.owner, value.spender) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for allowanceCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - owner: tuple.0, - spender: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: allowanceReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "allowance(address,address)"; - const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.owner, - ), - ::tokenize( - &self.spender, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: allowanceReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: approveCall) -> Self { - (value.spender, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for approveCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - spender: tuple.0, - amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: approveReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "approve(address,uint256)"; - const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.spender, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: approveReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: balanceOfCall) -> Self { - (value.account,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for balanceOfCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { account: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: balanceOfReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "balanceOf(address)"; - const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.account, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: balanceOfReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `balanceOfUnderlying(address)` and selector `0x3af9e669`. -```solidity -function balanceOfUnderlying(address) external pure returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct balanceOfUnderlyingCall(pub alloy::sol_types::private::Address); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`balanceOfUnderlying(address)`](balanceOfUnderlyingCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct balanceOfUnderlyingReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: balanceOfUnderlyingCall) -> Self { - (value.0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for balanceOfUnderlyingCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self(tuple.0) - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: balanceOfUnderlyingReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for balanceOfUnderlyingReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for balanceOfUnderlyingCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "balanceOfUnderlying(address)"; - const SELECTOR: [u8; 4] = [58u8, 249u8, 230u8, 105u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.0, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: balanceOfUnderlyingReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: balanceOfUnderlyingReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: decimalsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for decimalsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: decimalsReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for decimalsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for decimalsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = u8; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "decimals()"; - const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: decimalsReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: decreaseAllowanceCall) -> Self { - (value.spender, value.subtractedValue) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for decreaseAllowanceCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - spender: tuple.0, - subtractedValue: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: decreaseAllowanceReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)"; - const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.spender, - ), - as alloy_sol_types::SolType>::tokenize(&self.subtractedValue), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: decreaseAllowanceReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: increaseAllowanceCall) -> Self { - (value.spender, value.addedValue) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for increaseAllowanceCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - spender: tuple.0, - addedValue: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: increaseAllowanceReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "increaseAllowance(address,uint256)"; - const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.spender, - ), - as alloy_sol_types::SolType>::tokenize(&self.addedValue), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: increaseAllowanceReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `mint(uint256)` and selector `0xa0712d68`. -```solidity -function mint(uint256 mintAmount) external returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct mintCall { - #[allow(missing_docs)] - pub mintAmount: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`mint(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: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: mintCall) -> Self { - (value.mintAmount,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for mintCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { mintAmount: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: mintReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "mint(uint256)"; - const SELECTOR: [u8; 4] = [160u8, 113u8, 45u8, 104u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.mintAmount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: mintReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: nameCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for nameCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: nameReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for nameReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for nameCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::String; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "name()"; - const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: nameReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: ownerCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for ownerCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: ownerReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for ownerReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for ownerCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "owner()"; - const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: ownerReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: renounceOwnershipCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for renounceOwnershipCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: renounceOwnershipReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for renounceOwnershipReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl renounceOwnershipReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for renounceOwnershipCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = renounceOwnershipReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "renounceOwnership()"; - const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8]; - #[inline] - fn new<'a>( - tuple: 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 { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `sudoMint(address,uint256)` and selector `0x2d688ca8`. -```solidity -function sudoMint(address to, uint256 amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct sudoMintCall { - #[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 [`sudoMint(address,uint256)`](sudoMintCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct sudoMintReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: sudoMintCall) -> Self { - (value.to, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for sudoMintCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - to: tuple.0, - amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: sudoMintReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for sudoMintReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl sudoMintReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for sudoMintCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = sudoMintReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "sudoMint(address,uint256)"; - const SELECTOR: [u8; 4] = [45u8, 104u8, 140u8, 168u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.to, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - sudoMintReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: symbolCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for symbolCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: symbolReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for symbolReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for symbolCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::String; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "symbol()"; - const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: symbolReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: totalSupplyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for totalSupplyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: totalSupplyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for totalSupplyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for totalSupplyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "totalSupply()"; - const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: totalSupplyReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferCall) -> Self { - (value.to, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for transferCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - to: tuple.0, - amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "transfer(address,uint256)"; - const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.to, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: transferReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferFromCall) -> Self { - (value.from, value.to, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for transferFromCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - from: tuple.0, - to: tuple.1, - amount: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferFromReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "transferFrom(address,address,uint256)"; - const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.from, - ), - ::tokenize( - &self.to, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: transferFromReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: transferOwnershipCall) -> Self { - (value.newOwner,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for transferOwnershipCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { newOwner: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: transferOwnershipReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for transferOwnershipReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl transferOwnershipReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for transferOwnershipCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = transferOwnershipReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "transferOwnership(address)"; - const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::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 { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`DummyShoeBillToken`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum DummyShoeBillTokenCalls { - #[allow(missing_docs)] - allowance(allowanceCall), - #[allow(missing_docs)] - approve(approveCall), - #[allow(missing_docs)] - balanceOf(balanceOfCall), - #[allow(missing_docs)] - balanceOfUnderlying(balanceOfUnderlyingCall), - #[allow(missing_docs)] - decimals(decimalsCall), - #[allow(missing_docs)] - decreaseAllowance(decreaseAllowanceCall), - #[allow(missing_docs)] - increaseAllowance(increaseAllowanceCall), - #[allow(missing_docs)] - mint(mintCall), - #[allow(missing_docs)] - name(nameCall), - #[allow(missing_docs)] - owner(ownerCall), - #[allow(missing_docs)] - renounceOwnership(renounceOwnershipCall), - #[allow(missing_docs)] - sudoMint(sudoMintCall), - #[allow(missing_docs)] - symbol(symbolCall), - #[allow(missing_docs)] - totalSupply(totalSupplyCall), - #[allow(missing_docs)] - transfer(transferCall), - #[allow(missing_docs)] - transferFrom(transferFromCall), - #[allow(missing_docs)] - transferOwnership(transferOwnershipCall), - } - #[automatically_derived] - impl DummyShoeBillTokenCalls { - /// 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], - [45u8, 104u8, 140u8, 168u8], - [49u8, 60u8, 229u8, 103u8], - [57u8, 80u8, 147u8, 81u8], - [58u8, 249u8, 230u8, 105u8], - [112u8, 160u8, 130u8, 49u8], - [113u8, 80u8, 24u8, 166u8], - [141u8, 165u8, 203u8, 91u8], - [149u8, 216u8, 155u8, 65u8], - [160u8, 113u8, 45u8, 104u8], - [164u8, 87u8, 194u8, 215u8], - [169u8, 5u8, 156u8, 187u8], - [221u8, 98u8, 237u8, 62u8], - [242u8, 253u8, 227u8, 139u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for DummyShoeBillTokenCalls { - const NAME: &'static str = "DummyShoeBillTokenCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 17usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::allowance(_) => { - ::SELECTOR - } - Self::approve(_) => ::SELECTOR, - Self::balanceOf(_) => { - ::SELECTOR - } - Self::balanceOfUnderlying(_) => { - ::SELECTOR - } - Self::decimals(_) => ::SELECTOR, - Self::decreaseAllowance(_) => { - ::SELECTOR - } - Self::increaseAllowance(_) => { - ::SELECTOR - } - Self::mint(_) => ::SELECTOR, - Self::name(_) => ::SELECTOR, - Self::owner(_) => ::SELECTOR, - Self::renounceOwnership(_) => { - ::SELECTOR - } - Self::sudoMint(_) => ::SELECTOR, - Self::symbol(_) => ::SELECTOR, - Self::totalSupply(_) => { - ::SELECTOR - } - Self::transfer(_) => ::SELECTOR, - Self::transferFrom(_) => { - ::SELECTOR - } - Self::transferOwnership(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn name( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyShoeBillTokenCalls::name) - } - name - }, - { - fn approve( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyShoeBillTokenCalls::approve) - } - approve - }, - { - fn totalSupply( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummyShoeBillTokenCalls::totalSupply) - } - totalSupply - }, - { - fn transferFrom( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummyShoeBillTokenCalls::transferFrom) - } - transferFrom - }, - { - fn sudoMint( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyShoeBillTokenCalls::sudoMint) - } - sudoMint - }, - { - fn decimals( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyShoeBillTokenCalls::decimals) - } - decimals - }, - { - fn increaseAllowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummyShoeBillTokenCalls::increaseAllowance) - } - increaseAllowance - }, - { - fn balanceOfUnderlying( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummyShoeBillTokenCalls::balanceOfUnderlying) - } - balanceOfUnderlying - }, - { - fn balanceOf( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyShoeBillTokenCalls::balanceOf) - } - balanceOf - }, - { - fn renounceOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummyShoeBillTokenCalls::renounceOwnership) - } - renounceOwnership - }, - { - fn owner( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyShoeBillTokenCalls::owner) - } - owner - }, - { - fn symbol( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyShoeBillTokenCalls::symbol) - } - symbol - }, - { - fn mint( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyShoeBillTokenCalls::mint) - } - mint - }, - { - fn decreaseAllowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummyShoeBillTokenCalls::decreaseAllowance) - } - decreaseAllowance - }, - { - fn transfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyShoeBillTokenCalls::transfer) - } - transfer - }, - { - fn allowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(DummyShoeBillTokenCalls::allowance) - } - allowance - }, - { - fn transferOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummyShoeBillTokenCalls::transferOwnership) - } - transferOwnership - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn name( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyShoeBillTokenCalls::name) - } - name - }, - { - fn approve( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyShoeBillTokenCalls::approve) - } - approve - }, - { - fn totalSupply( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyShoeBillTokenCalls::totalSupply) - } - totalSupply - }, - { - fn transferFrom( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyShoeBillTokenCalls::transferFrom) - } - transferFrom - }, - { - fn sudoMint( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyShoeBillTokenCalls::sudoMint) - } - sudoMint - }, - { - fn decimals( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyShoeBillTokenCalls::decimals) - } - decimals - }, - { - fn increaseAllowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyShoeBillTokenCalls::increaseAllowance) - } - increaseAllowance - }, - { - fn balanceOfUnderlying( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyShoeBillTokenCalls::balanceOfUnderlying) - } - balanceOfUnderlying - }, - { - fn balanceOf( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyShoeBillTokenCalls::balanceOf) - } - balanceOf - }, - { - fn renounceOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyShoeBillTokenCalls::renounceOwnership) - } - renounceOwnership - }, - { - fn owner( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyShoeBillTokenCalls::owner) - } - owner - }, - { - fn symbol( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyShoeBillTokenCalls::symbol) - } - symbol - }, - { - fn mint( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyShoeBillTokenCalls::mint) - } - mint - }, - { - fn decreaseAllowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyShoeBillTokenCalls::decreaseAllowance) - } - decreaseAllowance - }, - { - fn transfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyShoeBillTokenCalls::transfer) - } - transfer - }, - { - fn allowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyShoeBillTokenCalls::allowance) - } - allowance - }, - { - fn transferOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummyShoeBillTokenCalls::transferOwnership) - } - transferOwnership - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::allowance(inner) => { - ::abi_encoded_size(inner) - } - Self::approve(inner) => { - ::abi_encoded_size(inner) - } - Self::balanceOf(inner) => { - ::abi_encoded_size(inner) - } - Self::balanceOfUnderlying(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::decimals(inner) => { - ::abi_encoded_size(inner) - } - Self::decreaseAllowance(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::increaseAllowance(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::mint(inner) => { - ::abi_encoded_size(inner) - } - Self::name(inner) => { - ::abi_encoded_size(inner) - } - Self::owner(inner) => { - ::abi_encoded_size(inner) - } - Self::renounceOwnership(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::sudoMint(inner) => { - ::abi_encoded_size(inner) - } - Self::symbol(inner) => { - ::abi_encoded_size(inner) - } - Self::totalSupply(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::transfer(inner) => { - ::abi_encoded_size(inner) - } - Self::transferFrom(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::transferOwnership(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::allowance(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::approve(inner) => { - ::abi_encode_raw(inner, out) - } - Self::balanceOf(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::balanceOfUnderlying(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::decimals(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::decreaseAllowance(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::increaseAllowance(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::mint(inner) => { - ::abi_encode_raw(inner, out) - } - Self::name(inner) => { - ::abi_encode_raw(inner, out) - } - Self::owner(inner) => { - ::abi_encode_raw(inner, out) - } - Self::renounceOwnership(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::sudoMint(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::symbol(inner) => { - ::abi_encode_raw(inner, out) - } - Self::totalSupply(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::transfer(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::transferFrom(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::transferOwnership(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`DummyShoeBillToken`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum DummyShoeBillTokenEvents { - #[allow(missing_docs)] - Approval(Approval), - #[allow(missing_docs)] - OwnershipTransferred(OwnershipTransferred), - #[allow(missing_docs)] - Transfer(Transfer), - } - #[automatically_derived] - impl DummyShoeBillTokenEvents { - /// 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]] = &[ - [ - 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, 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, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for DummyShoeBillTokenEvents { - const NAME: &'static str = "DummyShoeBillTokenEvents"; - const COUNT: usize = 3usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::Approval) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::OwnershipTransferred) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::Transfer) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 DummyShoeBillTokenEvents { - 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::OwnershipTransferred(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::OwnershipTransferred(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 as alloy_contract; - /**Creates a new wrapper around an on-chain [`DummyShoeBillToken`](self) contract instance. - -See the [wrapper's documentation](`DummyShoeBillTokenInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> DummyShoeBillTokenInstance { - DummyShoeBillTokenInstance::::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: alloy_contract::private::Network, - >( - provider: P, - name_: alloy::sol_types::private::String, - symbol_: alloy::sol_types::private::String, - _doMint: bool, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - DummyShoeBillTokenInstance::::deploy(provider, name_, symbol_, _doMint) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - name_: alloy::sol_types::private::String, - symbol_: alloy::sol_types::private::String, - _doMint: bool, - ) -> alloy_contract::RawCallBuilder { - DummyShoeBillTokenInstance::< - P, - N, - >::deploy_builder(provider, name_, symbol_, _doMint) - } - /**A [`DummyShoeBillToken`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`DummyShoeBillToken`](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 DummyShoeBillTokenInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for DummyShoeBillTokenInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("DummyShoeBillTokenInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummyShoeBillTokenInstance { - /**Creates a new wrapper around an on-chain [`DummyShoeBillToken`](self) contract instance. - -See the [wrapper's documentation](`DummyShoeBillTokenInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - name_: alloy::sol_types::private::String, - symbol_: alloy::sol_types::private::String, - _doMint: bool, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder(provider, name_, symbol_, _doMint); - 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, - name_: alloy::sol_types::private::String, - symbol_: alloy::sol_types::private::String, - _doMint: bool, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { - name_, - symbol_, - _doMint, - }, - )[..], - ] - .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 DummyShoeBillTokenInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> DummyShoeBillTokenInstance { - DummyShoeBillTokenInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummyShoeBillTokenInstance { - /// 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( - &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 [`balanceOfUnderlying`] function. - pub fn balanceOfUnderlying( - &self, - _0: alloy::sol_types::private::Address, - ) -> alloy_contract::SolCallBuilder<&P, balanceOfUnderlyingCall, N> { - self.call_builder(&balanceOfUnderlyingCall(_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 [`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 [`mint`] function. - pub fn mint( - &self, - mintAmount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> { - self.call_builder(&mintCall { mintAmount }) - } - ///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 [`renounceOwnership`] function. - pub fn renounceOwnership( - &self, - ) -> alloy_contract::SolCallBuilder<&P, renounceOwnershipCall, N> { - self.call_builder(&renounceOwnershipCall) - } - ///Creates a new call builder for the [`sudoMint`] function. - pub fn sudoMint( - &self, - to: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, sudoMintCall, N> { - self.call_builder(&sudoMintCall { to, amount }) - } - ///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, - 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, - }, - ) - } - ///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. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummyShoeBillTokenInstance { - /// 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( - &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::() - } - ///Creates a new event filter for the [`OwnershipTransferred`] event. - pub fn OwnershipTransferred_filter( - &self, - ) -> alloy_contract::Event<&P, OwnershipTransferred, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`Transfer`] event. - pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/dummy_solv_router.rs b/crates/bindings/src/dummy_solv_router.rs deleted file mode 100644 index e83bdf8b0..000000000 --- a/crates/bindings/src/dummy_solv_router.rs +++ /dev/null @@ -1,679 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface DummySolvRouter { - constructor(bool _doTransferAmount, address _solvBTC); - - function createSubscription(bytes32, uint256 amount) external returns (uint256 shareValue); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "_doTransferAmount", - "type": "bool", - "internalType": "bool" - }, - { - "name": "_solvBTC", - "type": "address", - "internalType": "contract ArbitaryErc20" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "createSubscription", - "inputs": [ - { - "name": "", - "type": "bytes32", - "internalType": "bytes32" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "shareValue", - "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 DummySolvRouter { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x6080604052348015600e575f5ffd5b5060405161023b38038061023b833981016040819052602b916064565b5f80546001600160a81b031916921515610100600160a81b031916929092176101006001600160a01b03929092169190910217905560a8565b5f5f604083850312156074575f5ffd5b825180151581146082575f5ffd5b60208401519092506001600160a01b0381168114609d575f5ffd5b809150509250929050565b610186806100b55f395ff3fe608060405234801561000f575f5ffd5b5060043610610029575f3560e01c80636d724ead1461002d575b5f5ffd5b61004061003b36600461010a565b610052565b60405190815260200160405180910390f35b5f805460ff1615610101575f546040517fa9059cbb0000000000000000000000000000000000000000000000000000000081523360048201526024810184905261010090910473ffffffffffffffffffffffffffffffffffffffff169063a9059cbb906044016020604051808303815f875af11580156100d4573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100f8919061012a565b50819050610104565b505f5b92915050565b5f5f6040838503121561011b575f5ffd5b50508035926020909101359150565b5f6020828403121561013a575f5ffd5b81518015158114610149575f5ffd5b939250505056fea264697066735822122043ca8c40391d178cae39779fe416a994c745d87dbd970c735590c0a6c88399c064736f6c634300081c0033 - /// ``` - #[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`@Qa\x02;8\x03\x80a\x02;\x839\x81\x01`@\x81\x90R`+\x91`dV[_\x80T`\x01`\x01`\xA8\x1B\x03\x19\x16\x92\x15\x15a\x01\0`\x01`\xA8\x1B\x03\x19\x16\x92\x90\x92\x17a\x01\0`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x02\x17\x90U`\xA8V[__`@\x83\x85\x03\x12\x15`tW__\xFD[\x82Q\x80\x15\x15\x81\x14`\x82W__\xFD[` \x84\x01Q\x90\x92P`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14`\x9DW__\xFD[\x80\x91PP\x92P\x92\x90PV[a\x01\x86\x80a\0\xB5_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0)W_5`\xE0\x1C\x80cmrN\xAD\x14a\0-W[__\xFD[a\0@a\0;6`\x04a\x01\nV[a\0RV[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[_\x80T`\xFF\x16\x15a\x01\x01W_T`@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\x81R3`\x04\x82\x01R`$\x81\x01\x84\x90Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90c\xA9\x05\x9C\xBB\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\0\xD4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\0\xF8\x91\x90a\x01*V[P\x81\x90Pa\x01\x04V[P_[\x92\x91PPV[__`@\x83\x85\x03\x12\x15a\x01\x1BW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x01:W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x01IW__\xFD[\x93\x92PPPV\xFE\xA2dipfsX\"\x12 C\xCA\x8C@9\x1D\x17\x8C\xAE9w\x9F\xE4\x16\xA9\x94\xC7E\xD8}\xBD\x97\x0CsU\x90\xC0\xA6\xC8\x83\x99\xC0dsolcC\0\x08\x1C\x003", - ); - /// The runtime bytecode of the contract, as deployed on the network. - /// - /// ```text - ///0x608060405234801561000f575f5ffd5b5060043610610029575f3560e01c80636d724ead1461002d575b5f5ffd5b61004061003b36600461010a565b610052565b60405190815260200160405180910390f35b5f805460ff1615610101575f546040517fa9059cbb0000000000000000000000000000000000000000000000000000000081523360048201526024810184905261010090910473ffffffffffffffffffffffffffffffffffffffff169063a9059cbb906044016020604051808303815f875af11580156100d4573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100f8919061012a565b50819050610104565b505f5b92915050565b5f5f6040838503121561011b575f5ffd5b50508035926020909101359150565b5f6020828403121561013a575f5ffd5b81518015158114610149575f5ffd5b939250505056fea264697066735822122043ca8c40391d178cae39779fe416a994c745d87dbd970c735590c0a6c88399c064736f6c634300081c0033 - /// ``` - #[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\x80cmrN\xAD\x14a\0-W[__\xFD[a\0@a\0;6`\x04a\x01\nV[a\0RV[`@Q\x90\x81R` \x01`@Q\x80\x91\x03\x90\xF3[_\x80T`\xFF\x16\x15a\x01\x01W_T`@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\x81R3`\x04\x82\x01R`$\x81\x01\x84\x90Ra\x01\0\x90\x91\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90c\xA9\x05\x9C\xBB\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\0\xD4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\0\xF8\x91\x90a\x01*V[P\x81\x90Pa\x01\x04V[P_[\x92\x91PPV[__`@\x83\x85\x03\x12\x15a\x01\x1BW__\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a\x01:W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x01IW__\xFD[\x93\x92PPPV\xFE\xA2dipfsX\"\x12 C\xCA\x8C@9\x1D\x17\x8C\xAE9w\x9F\xE4\x16\xA9\x94\xC7E\xD8}\xBD\x97\x0CsU\x90\xC0\xA6\xC8\x83\x99\xC0dsolcC\0\x08\x1C\x003", - ); - /**Constructor`. -```solidity -constructor(bool _doTransferAmount, address _solvBTC); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct constructorCall { - #[allow(missing_docs)] - pub _doTransferAmount: bool, - #[allow(missing_docs)] - pub _solvBTC: alloy::sol_types::private::Address, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Bool, - alloy::sol_types::sol_data::Address, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (bool, alloy::sol_types::private::Address); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value._doTransferAmount, value._solvBTC) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - _doTransferAmount: tuple.0, - _solvBTC: tuple.1, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolConstructor for constructorCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Bool, - alloy::sol_types::sol_data::Address, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._doTransferAmount, - ), - ::tokenize( - &self._solvBTC, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `createSubscription(bytes32,uint256)` and selector `0x6d724ead`. -```solidity -function createSubscription(bytes32, uint256 amount) external returns (uint256 shareValue); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct createSubscriptionCall { - #[allow(missing_docs)] - pub _0: alloy::sol_types::private::FixedBytes<32>, - #[allow(missing_docs)] - pub amount: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`createSubscription(bytes32,uint256)`](createSubscriptionCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct createSubscriptionReturn { - #[allow(missing_docs)] - pub shareValue: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: createSubscriptionCall) -> Self { - (value._0, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for createSubscriptionCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - _0: tuple.0, - amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: createSubscriptionReturn) -> Self { - (value.shareValue,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for createSubscriptionReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { shareValue: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for createSubscriptionCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "createSubscription(bytes32,uint256)"; - const SELECTOR: [u8; 4] = [109u8, 114u8, 78u8, 173u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: createSubscriptionReturn = r.into(); - r.shareValue - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: createSubscriptionReturn = r.into(); - r.shareValue - }) - } - } - }; - ///Container for all the [`DummySolvRouter`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum DummySolvRouterCalls { - #[allow(missing_docs)] - createSubscription(createSubscriptionCall), - } - #[automatically_derived] - impl DummySolvRouterCalls { - /// 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]] = &[[109u8, 114u8, 78u8, 173u8]]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for DummySolvRouterCalls { - const NAME: &'static str = "DummySolvRouterCalls"; - const MIN_DATA_LENGTH: usize = 64usize; - const COUNT: usize = 1usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::createSubscription(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn createSubscription( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(DummySolvRouterCalls::createSubscription) - } - createSubscription - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn createSubscription( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(DummySolvRouterCalls::createSubscription) - } - createSubscription - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::createSubscription(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::createSubscription(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`DummySolvRouter`](self) contract instance. - -See the [wrapper's documentation](`DummySolvRouterInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> DummySolvRouterInstance { - DummySolvRouterInstance::::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: alloy_contract::private::Network, - >( - provider: P, - _doTransferAmount: bool, - _solvBTC: alloy::sol_types::private::Address, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - DummySolvRouterInstance::::deploy(provider, _doTransferAmount, _solvBTC) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - _doTransferAmount: bool, - _solvBTC: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - DummySolvRouterInstance::< - P, - N, - >::deploy_builder(provider, _doTransferAmount, _solvBTC) - } - /**A [`DummySolvRouter`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`DummySolvRouter`](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 DummySolvRouterInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for DummySolvRouterInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("DummySolvRouterInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummySolvRouterInstance { - /**Creates a new wrapper around an on-chain [`DummySolvRouter`](self) contract instance. - -See the [wrapper's documentation](`DummySolvRouterInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - _doTransferAmount: bool, - _solvBTC: alloy::sol_types::private::Address, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder( - provider, - _doTransferAmount, - _solvBTC, - ); - 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, - _doTransferAmount: bool, - _solvBTC: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { - _doTransferAmount, - _solvBTC, - }, - )[..], - ] - .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 DummySolvRouterInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> DummySolvRouterInstance { - DummySolvRouterInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummySolvRouterInstance { - /// 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( - &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 [`createSubscription`] function. - pub fn createSubscription( - &self, - _0: alloy::sol_types::private::FixedBytes<32>, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, createSubscriptionCall, N> { - self.call_builder( - &createSubscriptionCall { - _0, - amount, - }, - ) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > DummySolvRouterInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/erc20.rs b/crates/bindings/src/erc20.rs deleted file mode 100644 index 1286d9747..000000000 --- a/crates/bindings/src/erc20.rs +++ /dev/null @@ -1,3224 +0,0 @@ -/** - -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 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": "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": "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" - }, - { - "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::*; - use alloy::sol_types as 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__\xFD[P`@Qa\r\x0C8\x03\x80a\r\x0C\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\xECV[`\x03a\0:\x83\x82a\x01\xD5V[P`\x04a\0G\x82\x82a\x01\xD5V[PPPa\x02\x8FV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x82`\x1F\x83\x01\x12a\0rW__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\0\x8BWa\0\x8Ba\0OV[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\0\xB9Wa\0\xB9a\0OV[`@R\x81\x81R\x83\x82\x01` \x01\x85\x10\x15a\0\xD0W__\xFD[\x81` \x85\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[__`@\x83\x85\x03\x12\x15a\0\xFDW__\xFD[\x82Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\x12W__\xFD[a\x01\x1E\x85\x82\x86\x01a\0cV[` \x85\x01Q\x90\x93P\x90P`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01;W__\xFD[a\x01G\x85\x82\x86\x01a\0cV[\x91PP\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x01eW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x01\x83WcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\x01\xD0W\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x01\xAEWP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x01\xCDW_\x81U`\x01\x01a\x01\xBAV[PP[PPPV[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\xEEWa\x01\xEEa\0OV[a\x02\x02\x81a\x01\xFC\x84Ta\x01QV[\x84a\x01\x89V[` `\x1F\x82\x11`\x01\x81\x14a\x024W_\x83\x15a\x02\x1DWP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x01\xCDV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x02cW\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x02CV[P\x84\x82\x10\x15a\x02\x80W\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[a\np\x80a\x02\x9C_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xC4W_5`\xE0\x1C\x80c9P\x93Q\x11a\0}W\x80c\xA4W\xC2\xD7\x11a\0XW\x80c\xA4W\xC2\xD7\x14a\x01\x8DW\x80c\xA9\x05\x9C\xBB\x14a\x01\xA0W\x80c\xDDb\xED>\x14a\x01\xB3W__\xFD[\x80c9P\x93Q\x14a\x01=W\x80cp\xA0\x821\x14a\x01PW\x80c\x95\xD8\x9BA\x14a\x01\x85W__\xFD[\x80c\x18\x16\r\xDD\x11a\0\xADW\x80c\x18\x16\r\xDD\x14a\x01\tW\x80c#\xB8r\xDD\x14a\x01\x1BW\x80c1<\xE5g\x14a\x01.W__\xFD[\x80c\x06\xFD\xDE\x03\x14a\0\xC8W\x80c\t^\xA7\xB3\x14a\0\xE6W[__\xFD[a\0\xD0a\x01\xF8V[`@Qa\0\xDD\x91\x90a\x08\x83V[`@Q\x80\x91\x03\x90\xF3[a\0\xF9a\0\xF46`\x04a\x08\xFEV[a\x02\x88V[`@Q\x90\x15\x15\x81R` \x01a\0\xDDV[`\x02T[`@Q\x90\x81R` \x01a\0\xDDV[a\0\xF9a\x01)6`\x04a\t&V[a\x02\xA1V[`@Q`\x12\x81R` \x01a\0\xDDV[a\0\xF9a\x01K6`\x04a\x08\xFEV[a\x02\xC4V[a\x01\ra\x01^6`\x04a\t`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 T\x90V[a\0\xD0a\x03\x0FV[a\0\xF9a\x01\x9B6`\x04a\x08\xFEV[a\x03\x1EV[a\0\xF9a\x01\xAE6`\x04a\x08\xFEV[a\x03\xD9V[a\x01\ra\x01\xC16`\x04a\t\x80V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x91\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[```\x03\x80Ta\x02\x07\x90a\t\xB1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x023\x90a\t\xB1V[\x80\x15a\x02~W\x80`\x1F\x10a\x02UWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02~V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02aW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[_3a\x02\x95\x81\x85\x85a\x03\xE6V[`\x01\x91PP[\x92\x91PPV[_3a\x02\xAE\x85\x82\x85a\x05dV[a\x02\xB9\x85\x85\x85a\x06 V[P`\x01\x94\x93PPPPV[3_\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\x91\x90a\x02\x95\x90\x82\x90\x86\x90a\x03\n\x90\x87\x90a\n\x02V[a\x03\xE6V[```\x04\x80Ta\x02\x07\x90a\t\xB1V[3_\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\x91\x90\x83\x81\x10\x15a\x03\xCCW`@QbF\x1B\xCD`\xE5\x1B\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\x01[`@Q\x80\x91\x03\x90\xFD[a\x02\xB9\x82\x86\x86\x84\x03a\x03\xE6V[_3a\x02\x95\x81\x85\x85a\x06 V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16a\x04nW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC3V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16a\x04\xF7W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC3V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x81\x16_\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\x81\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R 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\x81\x14a\x06\x1AW\x81\x81\x10\x15a\x06\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FERC20: insufficient allowance\0\0\0`D\x82\x01R`d\x01a\x03\xC3V[a\x06\x1A\x84\x84\x84\x84\x03a\x03\xE6V[PPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16a\x06\xA9W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC3V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16a\x072W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC3V[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 T\x81\x81\x10\x15a\x07\xCDW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC3V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16_\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R\x90\x81 \x80T\x84\x92\x90a\x08\x10\x90\x84\x90a\n\x02V[\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\x08v\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3a\x06\x1AV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\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\x84\x01\x01\x91PP\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\x08\xF9W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\t\x0FW__\xFD[a\t\x18\x83a\x08\xD6V[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\t8W__\xFD[a\tA\x84a\x08\xD6V[\x92Pa\tO` \x85\x01a\x08\xD6V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\tpW__\xFD[a\ty\x82a\x08\xD6V[\x93\x92PPPV[__`@\x83\x85\x03\x12\x15a\t\x91W__\xFD[a\t\x9A\x83a\x08\xD6V[\x91Pa\t\xA8` \x84\x01a\x08\xD6V[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\t\xC5W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\t\xFCW\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[P\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02\x9BW\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\xFE\xA2dipfsX\"\x12 \x80\x1A\x0B]\xB9\xB4\x9B\xDA\xD7~\x05HH\xEE\"\xCB\x0F\x91\xE2\xE3`\x06\xC4g\x94#2\x17\xFD\xF6\xFA,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\0\xC4W_5`\xE0\x1C\x80c9P\x93Q\x11a\0}W\x80c\xA4W\xC2\xD7\x11a\0XW\x80c\xA4W\xC2\xD7\x14a\x01\x8DW\x80c\xA9\x05\x9C\xBB\x14a\x01\xA0W\x80c\xDDb\xED>\x14a\x01\xB3W__\xFD[\x80c9P\x93Q\x14a\x01=W\x80cp\xA0\x821\x14a\x01PW\x80c\x95\xD8\x9BA\x14a\x01\x85W__\xFD[\x80c\x18\x16\r\xDD\x11a\0\xADW\x80c\x18\x16\r\xDD\x14a\x01\tW\x80c#\xB8r\xDD\x14a\x01\x1BW\x80c1<\xE5g\x14a\x01.W__\xFD[\x80c\x06\xFD\xDE\x03\x14a\0\xC8W\x80c\t^\xA7\xB3\x14a\0\xE6W[__\xFD[a\0\xD0a\x01\xF8V[`@Qa\0\xDD\x91\x90a\x08\x83V[`@Q\x80\x91\x03\x90\xF3[a\0\xF9a\0\xF46`\x04a\x08\xFEV[a\x02\x88V[`@Q\x90\x15\x15\x81R` \x01a\0\xDDV[`\x02T[`@Q\x90\x81R` \x01a\0\xDDV[a\0\xF9a\x01)6`\x04a\t&V[a\x02\xA1V[`@Q`\x12\x81R` \x01a\0\xDDV[a\0\xF9a\x01K6`\x04a\x08\xFEV[a\x02\xC4V[a\x01\ra\x01^6`\x04a\t`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 T\x90V[a\0\xD0a\x03\x0FV[a\0\xF9a\x01\x9B6`\x04a\x08\xFEV[a\x03\x1EV[a\0\xF9a\x01\xAE6`\x04a\x08\xFEV[a\x03\xD9V[a\x01\ra\x01\xC16`\x04a\t\x80V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x91\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x90\x94\x16\x82R\x91\x90\x91R T\x90V[```\x03\x80Ta\x02\x07\x90a\t\xB1V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x023\x90a\t\xB1V[\x80\x15a\x02~W\x80`\x1F\x10a\x02UWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02~V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x02aW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x90V[_3a\x02\x95\x81\x85\x85a\x03\xE6V[`\x01\x91PP[\x92\x91PPV[_3a\x02\xAE\x85\x82\x85a\x05dV[a\x02\xB9\x85\x85\x85a\x06 V[P`\x01\x94\x93PPPPV[3_\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\x91\x90a\x02\x95\x90\x82\x90\x86\x90a\x03\n\x90\x87\x90a\n\x02V[a\x03\xE6V[```\x04\x80Ta\x02\x07\x90a\t\xB1V[3_\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\x91\x90\x83\x81\x10\x15a\x03\xCCW`@QbF\x1B\xCD`\xE5\x1B\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\x01[`@Q\x80\x91\x03\x90\xFD[a\x02\xB9\x82\x86\x86\x84\x03a\x03\xE6V[_3a\x02\x95\x81\x85\x85a\x06 V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16a\x04nW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC3V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16a\x04\xF7W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC3V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x81\x16_\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\x81\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x86\x16\x83R\x92\x90R 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\x81\x14a\x06\x1AW\x81\x81\x10\x15a\x06\rW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FERC20: insufficient allowance\0\0\0`D\x82\x01R`d\x01a\x03\xC3V[a\x06\x1A\x84\x84\x84\x84\x03a\x03\xE6V[PPPPV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16a\x06\xA9W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC3V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x16a\x072W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC3V[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 T\x81\x81\x10\x15a\x07\xCDW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xC3V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16_\x90\x81R` \x81\x90R`@\x80\x82 \x85\x85\x03\x90U\x91\x85\x16\x81R\x90\x81 \x80T\x84\x92\x90a\x08\x10\x90\x84\x90a\n\x02V[\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\x08v\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3a\x06\x1AV[` \x81R_\x82Q\x80` \x84\x01R\x80` \x85\x01`@\x85\x01^_`@\x82\x85\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\x84\x01\x01\x91PP\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\x08\xF9W__\xFD[\x91\x90PV[__`@\x83\x85\x03\x12\x15a\t\x0FW__\xFD[a\t\x18\x83a\x08\xD6V[\x94` \x93\x90\x93\x015\x93PPPV[___``\x84\x86\x03\x12\x15a\t8W__\xFD[a\tA\x84a\x08\xD6V[\x92Pa\tO` \x85\x01a\x08\xD6V[\x92\x95\x92\x94PPP`@\x91\x90\x91\x015\x90V[_` \x82\x84\x03\x12\x15a\tpW__\xFD[a\ty\x82a\x08\xD6V[\x93\x92PPPV[__`@\x83\x85\x03\x12\x15a\t\x91W__\xFD[a\t\x9A\x83a\x08\xD6V[\x91Pa\t\xA8` \x84\x01a\x08\xD6V[\x90P\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\t\xC5W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\t\xFCW\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[P\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02\x9BW\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\xFE\xA2dipfsX\"\x12 \x80\x1A\x0B]\xB9\xB4\x9B\xDA\xD7~\x05HH\xEE\"\xCB\x0F\x91\xE2\xE3`\x06\xC4g\x94#2\x17\xFD\xF6\xFA,dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for Approval { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - 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, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - owner: topics.1, - spender: topics.2, - value: data.0, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.value), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = ::encode_topic( - &self.owner, - ); - out[2usize] = ::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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for Transfer { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - 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, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - from: topics.1, - to: topics.2, - value: data.0, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.value), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = ::encode_topic( - &self.from, - ); - out[2usize] = ::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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value.name_, value.symbol_) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.name_, - ), - ::tokenize( - &self.symbol_, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: allowanceCall) -> Self { - (value.owner, value.spender) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for allowanceCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - owner: tuple.0, - spender: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: allowanceReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "allowance(address,address)"; - const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.owner, - ), - ::tokenize( - &self.spender, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: allowanceReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: approveCall) -> Self { - (value.spender, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for approveCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - spender: tuple.0, - amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: approveReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "approve(address,uint256)"; - const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.spender, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: approveReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: balanceOfCall) -> Self { - (value.account,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for balanceOfCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { account: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: balanceOfReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "balanceOf(address)"; - const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.account, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: balanceOfReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: decimalsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for decimalsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: decimalsReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for decimalsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for decimalsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = u8; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "decimals()"; - const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: decimalsReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: decreaseAllowanceCall) -> Self { - (value.spender, value.subtractedValue) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for decreaseAllowanceCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - spender: tuple.0, - subtractedValue: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: decreaseAllowanceReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)"; - const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.spender, - ), - as alloy_sol_types::SolType>::tokenize(&self.subtractedValue), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: decreaseAllowanceReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: increaseAllowanceCall) -> Self { - (value.spender, value.addedValue) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for increaseAllowanceCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - spender: tuple.0, - addedValue: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: increaseAllowanceReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "increaseAllowance(address,uint256)"; - const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.spender, - ), - as alloy_sol_types::SolType>::tokenize(&self.addedValue), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: increaseAllowanceReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: nameCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for nameCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: nameReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for nameReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for nameCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::String; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "name()"; - const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: nameReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: symbolCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for symbolCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: symbolReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for symbolReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for symbolCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::String; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "symbol()"; - const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: symbolReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: totalSupplyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for totalSupplyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: totalSupplyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for totalSupplyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for totalSupplyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "totalSupply()"; - const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: totalSupplyReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferCall) -> Self { - (value.to, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for transferCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - to: tuple.0, - amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "transfer(address,uint256)"; - const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.to, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: transferReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferFromCall) -> Self { - (value.from, value.to, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for transferFromCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - from: tuple.0, - to: tuple.1, - amount: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferFromReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "transferFrom(address,address,uint256)"; - const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.from, - ), - ::tokenize( - &self.to, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - 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(serde::Serialize, serde::Deserialize)] - #[derive()] - 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), - } - #[automatically_derived] - 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], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for ERC20Calls { - const NAME: &'static str = "ERC20Calls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 11usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::allowance(_) => { - ::SELECTOR - } - Self::approve(_) => ::SELECTOR, - Self::balanceOf(_) => { - ::SELECTOR - } - Self::decimals(_) => ::SELECTOR, - Self::decreaseAllowance(_) => { - ::SELECTOR - } - Self::increaseAllowance(_) => { - ::SELECTOR - } - Self::name(_) => ::SELECTOR, - Self::symbol(_) => ::SELECTOR, - Self::totalSupply(_) => { - ::SELECTOR - } - Self::transfer(_) => ::SELECTOR, - Self::transferFrom(_) => { - ::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 { - static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result] = &[ - { - fn name(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ERC20Calls::name) - } - name - }, - { - fn approve(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ERC20Calls::approve) - } - approve - }, - { - fn totalSupply(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ERC20Calls::totalSupply) - } - totalSupply - }, - { - fn transferFrom(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ERC20Calls::transferFrom) - } - transferFrom - }, - { - fn decimals(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ERC20Calls::decimals) - } - decimals - }, - { - fn increaseAllowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ERC20Calls::increaseAllowance) - } - increaseAllowance - }, - { - fn balanceOf(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ERC20Calls::balanceOf) - } - balanceOf - }, - { - fn symbol(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ERC20Calls::symbol) - } - symbol - }, - { - fn decreaseAllowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ERC20Calls::decreaseAllowance) - } - decreaseAllowance - }, - { - fn transfer(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ERC20Calls::transfer) - } - transfer - }, - { - fn allowance(data: &[u8]) -> alloy_sol_types::Result { - ::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( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn name(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ERC20Calls::name) - } - name - }, - { - fn approve(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ERC20Calls::approve) - } - approve - }, - { - fn totalSupply(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ERC20Calls::totalSupply) - } - totalSupply - }, - { - fn transferFrom(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ERC20Calls::transferFrom) - } - transferFrom - }, - { - fn decimals(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ERC20Calls::decimals) - } - decimals - }, - { - fn increaseAllowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ERC20Calls::increaseAllowance) - } - increaseAllowance - }, - { - fn balanceOf(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ERC20Calls::balanceOf) - } - balanceOf - }, - { - fn symbol(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ERC20Calls::symbol) - } - symbol - }, - { - fn decreaseAllowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ERC20Calls::decreaseAllowance) - } - decreaseAllowance - }, - { - fn transfer(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ERC20Calls::transfer) - } - transfer - }, - { - fn allowance(data: &[u8]) -> alloy_sol_types::Result { - ::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( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::allowance(inner) => { - ::abi_encoded_size(inner) - } - Self::approve(inner) => { - ::abi_encoded_size(inner) - } - Self::balanceOf(inner) => { - ::abi_encoded_size(inner) - } - Self::decimals(inner) => { - ::abi_encoded_size(inner) - } - Self::decreaseAllowance(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::increaseAllowance(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::name(inner) => { - ::abi_encoded_size(inner) - } - Self::symbol(inner) => { - ::abi_encoded_size(inner) - } - Self::totalSupply(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::transfer(inner) => { - ::abi_encoded_size(inner) - } - Self::transferFrom(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::allowance(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::approve(inner) => { - ::abi_encode_raw(inner, out) - } - Self::balanceOf(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::decimals(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::decreaseAllowance(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::increaseAllowance(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::name(inner) => { - ::abi_encode_raw(inner, out) - } - Self::symbol(inner) => { - ::abi_encode_raw(inner, out) - } - Self::totalSupply(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::transfer(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::transferFrom(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`ERC20`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum ERC20Events { - #[allow(missing_docs)] - Approval(Approval), - #[allow(missing_docs)] - Transfer(Transfer), - } - #[automatically_derived] - 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, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for ERC20Events { - const NAME: &'static str = "ERC20Events"; - const COUNT: usize = 2usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::Approval) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::Transfer) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 as 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: alloy_contract::private::Network, - >(address: alloy_sol_types::private::Address, provider: P) -> ERC20Instance { - ERC20Instance::::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: alloy_contract::private::Network, - >( - provider: P, - name_: alloy::sol_types::private::String, - symbol_: alloy::sol_types::private::String, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - ERC20Instance::::deploy(provider, name_, symbol_) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - name_: alloy::sol_types::private::String, - symbol_: alloy::sol_types::private::String, - ) -> alloy_contract::RawCallBuilder { - ERC20Instance::::deploy_builder(provider, name_, symbol_) - } - /**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 { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for ERC20Instance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("ERC20Instance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ERC20Instance { - /**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, - _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, - name_: alloy::sol_types::private::String, - symbol_: alloy::sol_types::private::String, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder(provider, name_, symbol_); - 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, - name_: alloy::sol_types::private::String, - symbol_: alloy::sol_types::private::String, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { name_, symbol_ }, - )[..], - ] - .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 ERC20Instance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> ERC20Instance { - ERC20Instance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ERC20Instance { - /// 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( - &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, - 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. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ERC20Instance { - /// 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( - &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::() - } - ///Creates a new event filter for the [`Transfer`] event. - pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/erc2771_recipient.rs b/crates/bindings/src/erc2771_recipient.rs deleted file mode 100644 index 42aeadf67..000000000 --- a/crates/bindings/src/erc2771_recipient.rs +++ /dev/null @@ -1,735 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface ERC2771Recipient { - function getTrustedForwarder() external view returns (address forwarder); - function isTrustedForwarder(address forwarder) external view returns (bool); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "getTrustedForwarder", - "inputs": [], - "outputs": [ - { - "name": "forwarder", - "type": "address", - "internalType": "address" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "isTrustedForwarder", - "inputs": [ - { - "name": "forwarder", - "type": "address", - "internalType": "address" - } - ], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - } -] -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod ERC2771Recipient { - use super::*; - use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getTrustedForwarder()` and selector `0xce1b815f`. -```solidity -function getTrustedForwarder() external view returns (address forwarder); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getTrustedForwarderCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getTrustedForwarder()`](getTrustedForwarderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getTrustedForwarderReturn { - #[allow(missing_docs)] - pub forwarder: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getTrustedForwarderCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getTrustedForwarderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getTrustedForwarderReturn) -> Self { - (value.forwarder,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getTrustedForwarderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { forwarder: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getTrustedForwarderCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getTrustedForwarder()"; - const SELECTOR: [u8; 4] = [206u8, 27u8, 129u8, 95u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getTrustedForwarderReturn = r.into(); - r.forwarder - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getTrustedForwarderReturn = r.into(); - r.forwarder - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `isTrustedForwarder(address)` and selector `0x572b6c05`. -```solidity -function isTrustedForwarder(address forwarder) external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct isTrustedForwarderCall { - #[allow(missing_docs)] - pub forwarder: alloy::sol_types::private::Address, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`isTrustedForwarder(address)`](isTrustedForwarderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct isTrustedForwarderReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: isTrustedForwarderCall) -> Self { - (value.forwarder,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for isTrustedForwarderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { forwarder: tuple.0 } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: isTrustedForwarderReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for isTrustedForwarderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for isTrustedForwarderCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "isTrustedForwarder(address)"; - const SELECTOR: [u8; 4] = [87u8, 43u8, 108u8, 5u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.forwarder, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: isTrustedForwarderReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: isTrustedForwarderReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`ERC2771Recipient`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum ERC2771RecipientCalls { - #[allow(missing_docs)] - getTrustedForwarder(getTrustedForwarderCall), - #[allow(missing_docs)] - isTrustedForwarder(isTrustedForwarderCall), - } - #[automatically_derived] - impl ERC2771RecipientCalls { - /// 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]] = &[ - [87u8, 43u8, 108u8, 5u8], - [206u8, 27u8, 129u8, 95u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for ERC2771RecipientCalls { - const NAME: &'static str = "ERC2771RecipientCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 2usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::getTrustedForwarder(_) => { - ::SELECTOR - } - Self::isTrustedForwarder(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn isTrustedForwarder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ERC2771RecipientCalls::isTrustedForwarder) - } - isTrustedForwarder - }, - { - fn getTrustedForwarder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ERC2771RecipientCalls::getTrustedForwarder) - } - getTrustedForwarder - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn isTrustedForwarder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ERC2771RecipientCalls::isTrustedForwarder) - } - isTrustedForwarder - }, - { - fn getTrustedForwarder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ERC2771RecipientCalls::getTrustedForwarder) - } - getTrustedForwarder - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::getTrustedForwarder(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::isTrustedForwarder(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::getTrustedForwarder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::isTrustedForwarder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`ERC2771Recipient`](self) contract instance. - -See the [wrapper's documentation](`ERC2771RecipientInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> ERC2771RecipientInstance { - ERC2771RecipientInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - ERC2771RecipientInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - ERC2771RecipientInstance::::deploy_builder(provider) - } - /**A [`ERC2771Recipient`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`ERC2771Recipient`](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 ERC2771RecipientInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for ERC2771RecipientInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("ERC2771RecipientInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ERC2771RecipientInstance { - /**Creates a new wrapper around an on-chain [`ERC2771Recipient`](self) contract instance. - -See the [wrapper's documentation](`ERC2771RecipientInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 ERC2771RecipientInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> ERC2771RecipientInstance { - ERC2771RecipientInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ERC2771RecipientInstance { - /// 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( - &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 [`getTrustedForwarder`] function. - pub fn getTrustedForwarder( - &self, - ) -> alloy_contract::SolCallBuilder<&P, getTrustedForwarderCall, N> { - self.call_builder(&getTrustedForwarderCall) - } - ///Creates a new call builder for the [`isTrustedForwarder`] function. - pub fn isTrustedForwarder( - &self, - forwarder: alloy::sol_types::private::Address, - ) -> alloy_contract::SolCallBuilder<&P, isTrustedForwarderCall, N> { - self.call_builder( - &isTrustedForwarderCall { - forwarder, - }, - ) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ERC2771RecipientInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/forked_strategy_template_tbtc.rs b/crates/bindings/src/forked_strategy_template_tbtc.rs deleted file mode 100644 index f76f80720..000000000 --- a/crates/bindings/src/forked_strategy_template_tbtc.rs +++ /dev/null @@ -1,7635 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface ForkedStrategyTemplateTbtc { - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function token() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "simulateForkAndTransfer", - "inputs": [ - { - "name": "forkAtBlock", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "sender", - "type": "address", - "internalType": "address" - }, - { - "name": "receiver", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "token", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IERC20" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 ForkedStrategyTemplateTbtc { - use super::*; - use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. -```solidity -event log(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. -```solidity -function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferCall { - #[allow(missing_docs)] - pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub sender: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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::Uint<256>, - ); - #[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::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferCall) -> Self { - (value.forkAtBlock, value.sender, value.receiver, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - forkAtBlock: tuple.0, - sender: tuple.1, - receiver: tuple.2, - amount: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl simulateForkAndTransferReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for simulateForkAndTransferCall { - type Parameters<'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::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = simulateForkAndTransferReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; - const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), - ::tokenize( - &self.sender, - ), - ::tokenize( - &self.receiver, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - simulateForkAndTransferReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `token()` and selector `0xfc0c546a`. -```solidity -function token() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`token()`](tokenCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for tokenCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "token()"; - const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`ForkedStrategyTemplateTbtc`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum ForkedStrategyTemplateTbtcCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - simulateForkAndTransfer(simulateForkAndTransferCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - token(tokenCall), - } - #[automatically_derived] - impl ForkedStrategyTemplateTbtcCalls { - /// 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]] = &[ - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [102u8, 217u8, 169u8, 160u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [226u8, 12u8, 159u8, 113u8], - [249u8, 206u8, 14u8, 90u8], - [250u8, 118u8, 38u8, 212u8], - [252u8, 12u8, 84u8, 106u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for ForkedStrategyTemplateTbtcCalls { - const NAME: &'static str = "ForkedStrategyTemplateTbtcCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 14usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::simulateForkAndTransfer(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::token(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ForkedStrategyTemplateTbtcCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ForkedStrategyTemplateTbtcCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ForkedStrategyTemplateTbtcCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ForkedStrategyTemplateTbtcCalls::targetContracts) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - ForkedStrategyTemplateTbtcCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ForkedStrategyTemplateTbtcCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ForkedStrategyTemplateTbtcCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ForkedStrategyTemplateTbtcCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ForkedStrategyTemplateTbtcCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ForkedStrategyTemplateTbtcCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ForkedStrategyTemplateTbtcCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - ForkedStrategyTemplateTbtcCalls::simulateForkAndTransfer, - ) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ForkedStrategyTemplateTbtcCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ForkedStrategyTemplateTbtcCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateTbtcCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateTbtcCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateTbtcCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateTbtcCalls::targetContracts) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - ForkedStrategyTemplateTbtcCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateTbtcCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateTbtcCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateTbtcCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateTbtcCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateTbtcCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateTbtcCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - ForkedStrategyTemplateTbtcCalls::simulateForkAndTransfer, - ) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateTbtcCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateTbtcCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::token(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::token(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - ///Container for all the [`ForkedStrategyTemplateTbtc`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum ForkedStrategyTemplateTbtcEvents { - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl ForkedStrategyTemplateTbtcEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for ForkedStrategyTemplateTbtcEvents { - const NAME: &'static str = "ForkedStrategyTemplateTbtcEvents"; - const COUNT: usize = 22usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 ForkedStrategyTemplateTbtcEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`ForkedStrategyTemplateTbtc`](self) contract instance. - -See the [wrapper's documentation](`ForkedStrategyTemplateTbtcInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> ForkedStrategyTemplateTbtcInstance { - ForkedStrategyTemplateTbtcInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - ForkedStrategyTemplateTbtcInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - ForkedStrategyTemplateTbtcInstance::::deploy_builder(provider) - } - /**A [`ForkedStrategyTemplateTbtc`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`ForkedStrategyTemplateTbtc`](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 ForkedStrategyTemplateTbtcInstance< - P, - N = alloy_contract::private::Ethereum, - > { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for ForkedStrategyTemplateTbtcInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("ForkedStrategyTemplateTbtcInstance") - .field(&self.address) - .finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ForkedStrategyTemplateTbtcInstance { - /**Creates a new wrapper around an on-chain [`ForkedStrategyTemplateTbtc`](self) contract instance. - -See the [wrapper's documentation](`ForkedStrategyTemplateTbtcInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 ForkedStrategyTemplateTbtcInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> ForkedStrategyTemplateTbtcInstance { - ForkedStrategyTemplateTbtcInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ForkedStrategyTemplateTbtcInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`simulateForkAndTransfer`] function. - pub fn simulateForkAndTransfer( - &self, - forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - sender: alloy::sol_types::private::Address, - receiver: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { - self.call_builder( - &simulateForkAndTransferCall { - forkAtBlock, - sender, - receiver, - amount, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`token`] function. - pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { - self.call_builder(&tokenCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ForkedStrategyTemplateTbtcInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/forked_strategy_template_wbtc.rs b/crates/bindings/src/forked_strategy_template_wbtc.rs deleted file mode 100644 index 160f764d9..000000000 --- a/crates/bindings/src/forked_strategy_template_wbtc.rs +++ /dev/null @@ -1,7635 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface ForkedStrategyTemplateWbtc { - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function token() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "simulateForkAndTransfer", - "inputs": [ - { - "name": "forkAtBlock", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "sender", - "type": "address", - "internalType": "address" - }, - { - "name": "receiver", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "token", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IERC20" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 ForkedStrategyTemplateWbtc { - use super::*; - use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. -```solidity -event log(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. -```solidity -function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferCall { - #[allow(missing_docs)] - pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub sender: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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::Uint<256>, - ); - #[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::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferCall) -> Self { - (value.forkAtBlock, value.sender, value.receiver, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - forkAtBlock: tuple.0, - sender: tuple.1, - receiver: tuple.2, - amount: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl simulateForkAndTransferReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for simulateForkAndTransferCall { - type Parameters<'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::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = simulateForkAndTransferReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; - const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), - ::tokenize( - &self.sender, - ), - ::tokenize( - &self.receiver, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - simulateForkAndTransferReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `token()` and selector `0xfc0c546a`. -```solidity -function token() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`token()`](tokenCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for tokenCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "token()"; - const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`ForkedStrategyTemplateWbtc`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum ForkedStrategyTemplateWbtcCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - simulateForkAndTransfer(simulateForkAndTransferCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - token(tokenCall), - } - #[automatically_derived] - impl ForkedStrategyTemplateWbtcCalls { - /// 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]] = &[ - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [102u8, 217u8, 169u8, 160u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [226u8, 12u8, 159u8, 113u8], - [249u8, 206u8, 14u8, 90u8], - [250u8, 118u8, 38u8, 212u8], - [252u8, 12u8, 84u8, 106u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for ForkedStrategyTemplateWbtcCalls { - const NAME: &'static str = "ForkedStrategyTemplateWbtcCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 14usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::simulateForkAndTransfer(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::token(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ForkedStrategyTemplateWbtcCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ForkedStrategyTemplateWbtcCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ForkedStrategyTemplateWbtcCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ForkedStrategyTemplateWbtcCalls::targetContracts) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - ForkedStrategyTemplateWbtcCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ForkedStrategyTemplateWbtcCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ForkedStrategyTemplateWbtcCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ForkedStrategyTemplateWbtcCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ForkedStrategyTemplateWbtcCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ForkedStrategyTemplateWbtcCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ForkedStrategyTemplateWbtcCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - ForkedStrategyTemplateWbtcCalls::simulateForkAndTransfer, - ) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ForkedStrategyTemplateWbtcCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ForkedStrategyTemplateWbtcCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateWbtcCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateWbtcCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateWbtcCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateWbtcCalls::targetContracts) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - ForkedStrategyTemplateWbtcCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateWbtcCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateWbtcCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateWbtcCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateWbtcCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateWbtcCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateWbtcCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - ForkedStrategyTemplateWbtcCalls::simulateForkAndTransfer, - ) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateWbtcCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ForkedStrategyTemplateWbtcCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::token(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::token(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - ///Container for all the [`ForkedStrategyTemplateWbtc`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum ForkedStrategyTemplateWbtcEvents { - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl ForkedStrategyTemplateWbtcEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for ForkedStrategyTemplateWbtcEvents { - const NAME: &'static str = "ForkedStrategyTemplateWbtcEvents"; - const COUNT: usize = 22usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 ForkedStrategyTemplateWbtcEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`ForkedStrategyTemplateWbtc`](self) contract instance. - -See the [wrapper's documentation](`ForkedStrategyTemplateWbtcInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> ForkedStrategyTemplateWbtcInstance { - ForkedStrategyTemplateWbtcInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - ForkedStrategyTemplateWbtcInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - ForkedStrategyTemplateWbtcInstance::::deploy_builder(provider) - } - /**A [`ForkedStrategyTemplateWbtc`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`ForkedStrategyTemplateWbtc`](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 ForkedStrategyTemplateWbtcInstance< - P, - N = alloy_contract::private::Ethereum, - > { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for ForkedStrategyTemplateWbtcInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("ForkedStrategyTemplateWbtcInstance") - .field(&self.address) - .finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ForkedStrategyTemplateWbtcInstance { - /**Creates a new wrapper around an on-chain [`ForkedStrategyTemplateWbtc`](self) contract instance. - -See the [wrapper's documentation](`ForkedStrategyTemplateWbtcInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 ForkedStrategyTemplateWbtcInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> ForkedStrategyTemplateWbtcInstance { - ForkedStrategyTemplateWbtcInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ForkedStrategyTemplateWbtcInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`simulateForkAndTransfer`] function. - pub fn simulateForkAndTransfer( - &self, - forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - sender: alloy::sol_types::private::Address, - receiver: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { - self.call_builder( - &simulateForkAndTransferCall { - forkAtBlock, - sender, - receiver, - amount, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`token`] function. - pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { - self.call_builder(&tokenCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ForkedStrategyTemplateWbtcInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/hybrid_btc_strategy.rs b/crates/bindings/src/hybrid_btc_strategy.rs deleted file mode 100644 index 31267e787..000000000 --- a/crates/bindings/src/hybrid_btc_strategy.rs +++ /dev/null @@ -1,1788 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface HybridBTCStrategy { - struct StrategySlippageArgs { - uint256 amountOutMin; - } - - event TokenOutput(address tokenReceived, uint256 amountOut); - - constructor(address _boringVault, address _teller); - - function boringVault() external view returns (address); - function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; - function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; - function teller() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "_boringVault", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "_teller", - "type": "address", - "internalType": "contract ITeller" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "boringVault", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IERC20" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "handleGatewayMessage", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "message", - "type": "bytes", - "internalType": "bytes" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessageWithSlippageArgs", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "args", - "type": "tuple", - "internalType": "struct StrategySlippageArgs", - "components": [ - { - "name": "amountOutMin", - "type": "uint256", - "internalType": "uint256" - } - ] - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "teller", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract ITeller" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "TokenOutput", - "inputs": [ - { - "name": "tokenReceived", - "type": "address", - "indexed": false, - "internalType": "address" - }, - { - "name": "amountOut", - "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 HybridBTCStrategy { - use super::*; - use alloy::sol_types as 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\r\xD28\x03\x80a\r\xD2\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\xF5a\0\xDD_9_\x81\x81`h\x01Ra\x02\x87\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xC1\x01R\x81\x81a\x03\x0F\x01R\x81\x81a\x03}\x01Ra\x04\xB8\x01Ra\x0C\xF5_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cPcL\x0E\x14a\0NW\x80cW\xED\xABN\x14a\0cW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xF3\xB9w\x84\x14a\0\xC6W[__\xFD[a\0aa\0\\6`\x04a\n{V[a\0\xEDV[\0[a\0\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\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\0aa\0\xC16`\x04a\x0B=V[a\x01\x17V[a\0\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\x81V[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\xC1V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x16V[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\xDAV[`@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\x83\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B\xE5V[\x82Q`@Q\x7F\x0E\xFEj\x8B\0\0\0\0\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`$\x82\x01\x88\x90R`D\x82\x01\x92\x90\x92R\x91\x92P_\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\x90\x91\x16\x90c\x0E\xFEj\x8B\x90`d\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02\xCFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xF3\x91\x90a\x0B\xE5V[\x90Pa\x036s\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\x83a\x06\xD5V[`@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_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\xC4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xE8\x91\x90a\x0B\xE5V[\x90P\x82\x81\x11a\x04>W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x04I\x84\x83a\x0C)V[\x85Q\x90\x91P\x81\x10\x15a\x04\x9DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x045V[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\xD4\x90\x85\x90\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\x90`\x84\x01[`@\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\x070V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06NW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06r\x91\x90a\x0B\xE5V[a\x06|\x91\x90a\x0CBV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\xD4\x90\x85\x90\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\x90`d\x01a\x05pV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07+\x90\x84\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\x90`d\x01a\x05pV[PPPV[_a\x07\x91\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\x08!\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07+W\x80\x80` \x01\x90Q\x81\x01\x90a\x07\xAF\x91\x90a\x0CUV[a\x07+W`@QbF\x1B\xCD`\xE5\x1B\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\x045V[``a\x08/\x84\x84_\x85a\x089V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\xB1W`@QbF\x1B\xCD`\xE5\x1B\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\x045V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\x15W`@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\x045V[__\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\t=\x91\x90a\x0CtV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\twW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t|V[``\x91P[P\x91P\x91Pa\t\x8C\x82\x82\x86a\t\x97V[\x97\x96PPPPPPPV[``\x83\x15a\t\xA6WP\x81a\x082V[\x82Q\x15a\t\xB6W\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x045\x91\x90a\x0C\x8AV[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\t\xF1W__\xFD[PV[\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\nDWa\nDa\t\xF4V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\nsWa\nsa\t\xF4V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\n\x8EW__\xFD[\x845a\n\x99\x81a\t\xD0V[\x93P` \x85\x015\x92P`@\x85\x015a\n\xB0\x81a\t\xD0V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xCBW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\xDBW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xF5Wa\n\xF5a\t\xF4V[a\x0B\x08` `\x1F\x19`\x1F\x84\x01\x16\x01a\nJV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0B\x1CW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0BQW__\xFD[\x855a\x0B\\\x81a\t\xD0V[\x94P` \x86\x015\x93P`@\x86\x015a\x0Bs\x81a\t\xD0V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0B\xA4W__\xFD[Pa\x0B\xADa\n!V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\xD2W__\xFD[Pa\x0B\xDBa\n!V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xF5W__\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[\x81\x81\x03\x81\x81\x11\x15a\x0C=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B\xE5V[\x82Q`@Q\x7F\x0E\xFEj\x8B\0\0\0\0\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`$\x82\x01\x88\x90R`D\x82\x01\x92\x90\x92R\x91\x92P_\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\x90\x91\x16\x90c\x0E\xFEj\x8B\x90`d\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02\xCFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xF3\x91\x90a\x0B\xE5V[\x90Pa\x036s\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\x83a\x06\xD5V[`@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_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\xC4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xE8\x91\x90a\x0B\xE5V[\x90P\x82\x81\x11a\x04>W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x04I\x84\x83a\x0C)V[\x85Q\x90\x91P\x81\x10\x15a\x04\x9DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x045V[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\xD4\x90\x85\x90\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\x90`\x84\x01[`@\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\x070V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06NW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06r\x91\x90a\x0B\xE5V[a\x06|\x91\x90a\x0CBV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\xD4\x90\x85\x90\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\x90`d\x01a\x05pV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07+\x90\x84\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\x90`d\x01a\x05pV[PPPV[_a\x07\x91\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\x08!\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07+W\x80\x80` \x01\x90Q\x81\x01\x90a\x07\xAF\x91\x90a\x0CUV[a\x07+W`@QbF\x1B\xCD`\xE5\x1B\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\x045V[``a\x08/\x84\x84_\x85a\x089V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\xB1W`@QbF\x1B\xCD`\xE5\x1B\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\x045V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\x15W`@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\x045V[__\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\t=\x91\x90a\x0CtV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\twW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t|V[``\x91P[P\x91P\x91Pa\t\x8C\x82\x82\x86a\t\x97V[\x97\x96PPPPPPPV[``\x83\x15a\t\xA6WP\x81a\x082V[\x82Q\x15a\t\xB6W\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x045\x91\x90a\x0C\x8AV[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\t\xF1W__\xFD[PV[\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\nDWa\nDa\t\xF4V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\nsWa\nsa\t\xF4V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\n\x8EW__\xFD[\x845a\n\x99\x81a\t\xD0V[\x93P` \x85\x015\x92P`@\x85\x015a\n\xB0\x81a\t\xD0V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xCBW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\xDBW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xF5Wa\n\xF5a\t\xF4V[a\x0B\x08` `\x1F\x19`\x1F\x84\x01\x16\x01a\nJV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0B\x1CW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0BQW__\xFD[\x855a\x0B\\\x81a\t\xD0V[\x94P` \x86\x015\x93P`@\x86\x015a\x0Bs\x81a\t\xD0V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0B\xA4W__\xFD[Pa\x0B\xADa\n!V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\xD2W__\xFD[Pa\x0B\xDBa\n!V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xF5W__\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[\x81\x81\x03\x81\x81\x11\x15a\x0C = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: StrategySlippageArgs) -> Self { - (value.amountOutMin,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for StrategySlippageArgs { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { amountOutMin: tuple.0 } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for StrategySlippageArgs { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for StrategySlippageArgs { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for StrategySlippageArgs { - const NAME: &'static str = "StrategySlippageArgs"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "StrategySlippageArgs(uint256 amountOutMin)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) - .0 - .to_vec() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for StrategySlippageArgs { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.amountOutMin, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.amountOutMin, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. -```solidity -event TokenOutput(address tokenReceived, uint256 amountOut); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct TokenOutput { - #[allow(missing_docs)] - pub tokenReceived: alloy::sol_types::private::Address, - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for TokenOutput { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - tokenReceived: data.0, - amountOut: data.1, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.tokenReceived, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountOut), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 TokenOutput { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&TokenOutput> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - /**Constructor`. -```solidity -constructor(address _boringVault, address _teller); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct constructorCall { - #[allow(missing_docs)] - pub _boringVault: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub _teller: alloy::sol_types::private::Address, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value._boringVault, value._teller) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - _boringVault: tuple.0, - _teller: 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> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._boringVault, - ), - ::tokenize( - &self._teller, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `boringVault()` and selector `0xf3b97784`. -```solidity -function boringVault() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct boringVaultCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`boringVault()`](boringVaultCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct boringVaultReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: boringVaultCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for boringVaultCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: boringVaultReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for boringVaultReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for boringVaultCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "boringVault()"; - const SELECTOR: [u8; 4] = [243u8, 185u8, 119u8, 132u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: boringVaultReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: boringVaultReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. -```solidity -function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub message: alloy::sol_types::private::Bytes, - } - ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ); - #[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, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.message) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - message: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageCall { - 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, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; - const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.message, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. -```solidity -function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub args: ::RustType, - } - ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::primitives::aliases::U256, - alloy::sol_types::private::Address, - ::RustType, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.args) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - args: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageWithSlippageArgsReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageWithSlippageArgsReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; - const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.args, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `teller()` and selector `0x57edab4e`. -```solidity -function teller() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tellerCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`teller()`](tellerCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tellerReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tellerCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tellerCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tellerReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tellerReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for tellerCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "teller()"; - const SELECTOR: [u8; 4] = [87u8, 237u8, 171u8, 78u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: tellerReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: tellerReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`HybridBTCStrategy`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum HybridBTCStrategyCalls { - #[allow(missing_docs)] - boringVault(boringVaultCall), - #[allow(missing_docs)] - handleGatewayMessage(handleGatewayMessageCall), - #[allow(missing_docs)] - handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), - #[allow(missing_docs)] - teller(tellerCall), - } - #[automatically_derived] - impl HybridBTCStrategyCalls { - /// 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, 99u8, 76u8, 14u8], - [87u8, 237u8, 171u8, 78u8], - [127u8, 129u8, 79u8, 53u8], - [243u8, 185u8, 119u8, 132u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for HybridBTCStrategyCalls { - const NAME: &'static str = "HybridBTCStrategyCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 4usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::boringVault(_) => { - ::SELECTOR - } - Self::handleGatewayMessage(_) => { - ::SELECTOR - } - Self::handleGatewayMessageWithSlippageArgs(_) => { - ::SELECTOR - } - Self::teller(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(HybridBTCStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn teller( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(HybridBTCStrategyCalls::teller) - } - teller - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - HybridBTCStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - { - fn boringVault( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(HybridBTCStrategyCalls::boringVault) - } - boringVault - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(HybridBTCStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn teller( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(HybridBTCStrategyCalls::teller) - } - teller - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - HybridBTCStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - { - fn boringVault( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(HybridBTCStrategyCalls::boringVault) - } - boringVault - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::boringVault(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::handleGatewayMessage(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::teller(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::boringVault(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::handleGatewayMessage(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::teller(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - ///Container for all the [`HybridBTCStrategy`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum HybridBTCStrategyEvents { - #[allow(missing_docs)] - TokenOutput(TokenOutput), - } - #[automatically_derived] - impl HybridBTCStrategyEvents { - /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for HybridBTCStrategyEvents { - const NAME: &'static str = "HybridBTCStrategyEvents"; - const COUNT: usize = 1usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::TokenOutput) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 HybridBTCStrategyEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`HybridBTCStrategy`](self) contract instance. - -See the [wrapper's documentation](`HybridBTCStrategyInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> HybridBTCStrategyInstance { - HybridBTCStrategyInstance::::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: alloy_contract::private::Network, - >( - provider: P, - _boringVault: alloy::sol_types::private::Address, - _teller: alloy::sol_types::private::Address, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - HybridBTCStrategyInstance::::deploy(provider, _boringVault, _teller) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - _boringVault: alloy::sol_types::private::Address, - _teller: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - HybridBTCStrategyInstance::< - P, - N, - >::deploy_builder(provider, _boringVault, _teller) - } - /**A [`HybridBTCStrategy`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`HybridBTCStrategy`](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 HybridBTCStrategyInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for HybridBTCStrategyInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("HybridBTCStrategyInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > HybridBTCStrategyInstance { - /**Creates a new wrapper around an on-chain [`HybridBTCStrategy`](self) contract instance. - -See the [wrapper's documentation](`HybridBTCStrategyInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - _boringVault: alloy::sol_types::private::Address, - _teller: alloy::sol_types::private::Address, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder(provider, _boringVault, _teller); - 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, - _boringVault: alloy::sol_types::private::Address, - _teller: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { - _boringVault, - _teller, - }, - )[..], - ] - .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 HybridBTCStrategyInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> HybridBTCStrategyInstance { - HybridBTCStrategyInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > HybridBTCStrategyInstance { - /// 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( - &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 [`boringVault`] function. - pub fn boringVault( - &self, - ) -> alloy_contract::SolCallBuilder<&P, boringVaultCall, N> { - self.call_builder(&boringVaultCall) - } - ///Creates a new call builder for the [`handleGatewayMessage`] function. - pub fn handleGatewayMessage( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - message: alloy::sol_types::private::Bytes, - ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { - self.call_builder( - &handleGatewayMessageCall { - tokenSent, - amountIn, - recipient, - message, - }, - ) - } - ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. - pub fn handleGatewayMessageWithSlippageArgs( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - args: ::RustType, - ) -> alloy_contract::SolCallBuilder< - &P, - handleGatewayMessageWithSlippageArgsCall, - N, - > { - self.call_builder( - &handleGatewayMessageWithSlippageArgsCall { - tokenSent, - amountIn, - recipient, - args, - }, - ) - } - ///Creates a new call builder for the [`teller`] function. - pub fn teller(&self) -> alloy_contract::SolCallBuilder<&P, tellerCall, N> { - self.call_builder(&tellerCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > HybridBTCStrategyInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`TokenOutput`] event. - pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/hybrid_btc_strategy_forked_wbtc.rs b/crates/bindings/src/hybrid_btc_strategy_forked_wbtc.rs deleted file mode 100644 index 5eab76562..000000000 --- a/crates/bindings/src/hybrid_btc_strategy_forked_wbtc.rs +++ /dev/null @@ -1,8360 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface HybridBTCStrategyForkedWbtc { - event TokenOutput(address tokenReceived, uint256 amountOut); - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - function IS_TEST() external view returns (bool); - function amountIn() external view returns (uint256); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function setUp() external; - function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function testDepositToVault() external; - function token() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "amountIn", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "setUp", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "simulateForkAndTransfer", - "inputs": [ - { - "name": "forkAtBlock", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "sender", - "type": "address", - "internalType": "address" - }, - { - "name": "receiver", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testDepositToVault", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "token", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IERC20" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "TokenOutput", - "inputs": [ - { - "name": "tokenReceived", - "type": "address", - "indexed": false, - "internalType": "address" - }, - { - "name": "amountOut", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 HybridBTCStrategyForkedWbtc { - use super::*; - use alloy::sol_types as 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`\x0C\x80T`\xFF\x19\x90\x81\x16`\x01\x90\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90Uc\x05\xF5\xE1\0` U`!\x80T`\x01`\x01`\xA0\x1B\x03\x19\x90\x81\x16s\x19\xAB\x8C\x98\x96r\x8D:*\xE8gw\x11\xBC\x85,pf\x16\xD3\x17\x90\x91U`\"\x80T\x90\x91\x16s\x99\x98\xE0P0\xAE\xE3\xAF\x9A\xD3\xDF5\xA3O\\Q\xE1b\x87y\x17\x90U4\x80\x15`|W__\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16t\x03\xC7\x05K\xCB9\xF7\xB2\xE5\xB2\xC7\xAC\xB3u\x83\xE3-p\xCF\xA3\0\x17\x90Ua&\xF8\x80a\0\xB2_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80c\x8C\x198a\x11a\0\xADW\x80c\xBAAO\xA6\x11a\0}W\x80c\xF9\xCE\x0EZ\x11a\0cW\x80c\xF9\xCE\x0EZ\x14a\x01\xF4W\x80c\xFAv&\xD4\x14a\x02\x07W\x80c\xFC\x0CTj\x14a\x02\x14W__\xFD[\x80c\xBAAO\xA6\x14a\x01\xD4W\x80c\xE2\x0C\x9Fq\x14a\x01\xECW__\xFD[\x80c\x8C\x198a\x14a\x01\xA7W\x80c\x91j\x17\xC6\x14a\x01\xAFW\x80c\xB0FO\xDC\x14a\x01\xC4W\x80c\xB5P\x8A\xA9\x14a\x01\xCCW__\xFD[\x80c?r\x86\xF4\x11a\0\xE8W\x80c?r\x86\xF4\x14a\x01^W\x80cf\xD9\xA9\xA0\x14a\x01fW\x80ck\xEDU\xA6\x14a\x01{W\x80c\x85\"l\x81\x14a\x01\x92W__\xFD[\x80c\n\x92T\xE4\x14a\x01\x19W\x80c\x1E\xD7\x83\x1C\x14a\x01#W\x80c*\xDE8\x80\x14a\x01AW\x80c>^<#\x14a\x01VW[__\xFD[a\x01!a\x02DV[\0[a\x01+a\x03\nV[`@Qa\x018\x91\x90a\x13\xBEV[`@Q\x80\x91\x03\x90\xF3[a\x01Ia\x03jV[`@Qa\x018\x91\x90a\x147V[a\x01+a\x04\xA6V[a\x01+a\x05\x04V[a\x01na\x05bV[`@Qa\x018\x91\x90a\x15zV[a\x01\x84` T\x81V[`@Q\x90\x81R` \x01a\x018V[a\x01\x9Aa\x06\xDBV[`@Qa\x018\x91\x90a\x15\xF8V[a\x01!a\x07\xA6V[a\x01\xB7a\r\rV[`@Qa\x018\x91\x90a\x16OV[a\x01\xB7a\x0E\x03V[a\x01\x9Aa\x0E\xF9V[a\x01\xDCa\x0F\xC4V[`@Q\x90\x15\x15\x81R` \x01a\x018V[a\x01+a\x10\x94V[a\x01!a\x02\x026`\x04a\x16\xE1V[a\x10\xF2V[`\x1FTa\x01\xDC\x90`\xFF\x16\x81V[`\x1FTa\x02,\x90a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x018V[a\x02}b\xD5\x9F\x80sJ\x1D\xF9qaG\xB7\x85\xF3\xF8 \x19\xF3o$\x8A\xC1]\xC3\x08s\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E` Ta\x10\xF2V[`\"T`!T`@Q`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x92\x90\x91\x16\x90a\x02\x9F\x90a\x13\xB1V[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x02\xCFW=__>=_\xFD[P`#\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`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03`W` \x02\x82\x01\x91\x90_R` _ \x90[\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03BW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\x86W\x83\x82\x90_R` _ \x01\x80Ta\x03\xFB\x90a\x17\"V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x04'\x90a\x17\"V[\x80\x15a\x04rW\x80`\x1F\x10a\x04IWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x04rV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x04UW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03\xDEV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x03\x8DV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03`W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03BWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03`W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03BWPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x05\xB5\x90a\x17\"V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05\xE1\x90a\x17\"V[\x80\x15a\x06,W\x80`\x1F\x10a\x06\x03Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x06,V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x06\x0FW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06\xC3W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x06pW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05\x85V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW\x83\x82\x90_R` _ \x01\x80Ta\x07\x1B\x90a\x17\"V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07G\x90a\x17\"V[\x80\x15a\x07\x92W\x80`\x1F\x10a\x07iWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07\x92V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07uW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x06\xFEV[`\x1FT`@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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R_\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x1EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08B\x91\x90a\x17sV[`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\xBBW__\xFD[PZ\xF1\x15\x80\x15a\x08\xCDW=__>=_\xFD[PP`\x1FT`#T` T`@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\x81R`\x01`\x01`\xA0\x1B\x03\x92\x83\x16`\x04\x82\x01R`$\x81\x01\x91\x90\x91Ra\x01\0\x90\x92\x04\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\tEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\ti\x91\x90a\x17\x8AV[P`#T`@Q\x7F\x86\xB9b\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\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x86\xB9b\r\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t\xD9W__\xFD[PZ\xF1\x15\x80\x15a\t\xEBW=__>=_\xFD[PP`\"T` \x80T`@\x80Q`\x01`\x01`\xA0\x1B\x03\x90\x94\x16\x84R\x91\x83\x01R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x93P\x01\x90P`@Q\x80\x91\x03\x90\xA1`#T`\x1FT` \x80T`@\x80Q\x92\x83\x01\x81R_\x83RQ\x7F\x7F\x81O5\0\0\0\0\0\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\x03a\x01\0\x90\x94\x04\x84\x16`\x04\x82\x01R`$\x81\x01\x91\x90\x91R`\x01`D\x82\x01R\x90Q`d\x82\x01R\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\n\xBFW__\xFD[PZ\xF1\x15\x80\x15a\n\xD1W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0B!W__\xFD[PZ\xF1\x15\x80\x15a\x0B3W=__>=_\xFD[PP`\"T`@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\x81R`\x01`\x04\x82\x01Ra\x0B\xC7\x93P`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0B\x9BW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\xBF\x91\x90a\x17sV[` Ta\x13.V[`\"T`#T`@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\x81R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x04\x82\x01Ra\x0CZ\x92\x91\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0C0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0CT\x91\x90a\x17sV[_a\x13.V[`\x1FT`@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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01Ra\r\n\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0C\xD4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\xF8\x91\x90a\x17sV[` Ta\r\x05\x90\x84a\x17\xB0V[a\x13.V[PV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\xEBW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\x98W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\r0V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0E\xE1W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0E\x8EW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0E&V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW\x83\x82\x90_R` _ \x01\x80Ta\x0F9\x90a\x17\"V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0Fe\x90a\x17\"V[\x80\x15a\x0F\xB0W\x80`\x1F\x10a\x0F\x87Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F\xB0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\x93W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0F\x1CV[`\x08T_\x90`\xFF\x16\x15a\x0F\xDBWP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10iW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\x8D\x91\x90a\x17sV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03`W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03BWPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\x8DW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x11\xB4\x91\x90\x81\x01\x90a\x18\x1BV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x11\xD2\x92\x91\x90a\x18\xCFV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11\xEEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\x12\x91\x90a\x17sV[P`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12~W__\xFD[PZ\xF1\x15\x80\x15a\x12\x90W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x13\x03W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13'\x91\x90a\x17\x8AV[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x13\x97W__\xFD[PZ\xFA\x15\x80\x15a\x13\xA9W=__>=_\xFD[PPPPPPV[a\r\xD2\x80a\x18\xF1\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x13\xFEW\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x13\xD7V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x12W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`\x01`\x01`\xA0\x1B\x03\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x14\xF8W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x14\xE2\x84\x86Qa\x14\tV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x14\xA8V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x14]V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x15pW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x150V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x12W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x15\xC6`@\x88\x01\x82a\x14\tV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x15\xE1\x81\x83a\x15\x1EV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\xA0V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x12W`?\x19\x87\x86\x03\x01\x84Ra\x16:\x85\x83Qa\x14\tV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16\x1EV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x12W`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x16\xB0`@\x87\x01\x82a\x15\x1EV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16uV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x16\xDCW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x16\xF4W__\xFD[\x845\x93Pa\x17\x04` \x86\x01a\x16\xC6V[\x92Pa\x17\x12`@\x86\x01a\x16\xC6V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x176W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x17mW\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17\x83W__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17\x9AW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x17\xA9W__\xFD[\x93\x92PPPV[\x81\x81\x03\x81\x81\x11\x15a\x17\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`\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x18+W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18AW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x18QW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18kWa\x18ka\x17\xEEV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x18\x9BWa\x18\x9Ba\x17\xEEV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x18\xB2W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x18\xE1`@\x83\x01\x85a\x14\tV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\xD28\x03\x80a\r\xD2\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\xF5a\0\xDD_9_\x81\x81`h\x01Ra\x02\x87\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xC1\x01R\x81\x81a\x03\x0F\x01R\x81\x81a\x03}\x01Ra\x04\xB8\x01Ra\x0C\xF5_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cPcL\x0E\x14a\0NW\x80cW\xED\xABN\x14a\0cW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xF3\xB9w\x84\x14a\0\xC6W[__\xFD[a\0aa\0\\6`\x04a\n{V[a\0\xEDV[\0[a\0\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\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\0aa\0\xC16`\x04a\x0B=V[a\x01\x17V[a\0\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\x81V[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\xC1V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x16V[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\xDAV[`@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\x83\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B\xE5V[\x82Q`@Q\x7F\x0E\xFEj\x8B\0\0\0\0\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`$\x82\x01\x88\x90R`D\x82\x01\x92\x90\x92R\x91\x92P_\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\x90\x91\x16\x90c\x0E\xFEj\x8B\x90`d\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02\xCFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xF3\x91\x90a\x0B\xE5V[\x90Pa\x036s\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\x83a\x06\xD5V[`@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_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\xC4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xE8\x91\x90a\x0B\xE5V[\x90P\x82\x81\x11a\x04>W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x04I\x84\x83a\x0C)V[\x85Q\x90\x91P\x81\x10\x15a\x04\x9DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x045V[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\xD4\x90\x85\x90\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\x90`\x84\x01[`@\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\x070V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06NW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06r\x91\x90a\x0B\xE5V[a\x06|\x91\x90a\x0CBV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\xD4\x90\x85\x90\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\x90`d\x01a\x05pV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07+\x90\x84\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\x90`d\x01a\x05pV[PPPV[_a\x07\x91\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\x08!\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07+W\x80\x80` \x01\x90Q\x81\x01\x90a\x07\xAF\x91\x90a\x0CUV[a\x07+W`@QbF\x1B\xCD`\xE5\x1B\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\x045V[``a\x08/\x84\x84_\x85a\x089V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\xB1W`@QbF\x1B\xCD`\xE5\x1B\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\x045V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\x15W`@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\x045V[__\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\t=\x91\x90a\x0CtV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\twW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t|V[``\x91P[P\x91P\x91Pa\t\x8C\x82\x82\x86a\t\x97V[\x97\x96PPPPPPPV[``\x83\x15a\t\xA6WP\x81a\x082V[\x82Q\x15a\t\xB6W\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x045\x91\x90a\x0C\x8AV[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\t\xF1W__\xFD[PV[\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\nDWa\nDa\t\xF4V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\nsWa\nsa\t\xF4V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\n\x8EW__\xFD[\x845a\n\x99\x81a\t\xD0V[\x93P` \x85\x015\x92P`@\x85\x015a\n\xB0\x81a\t\xD0V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xCBW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\xDBW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xF5Wa\n\xF5a\t\xF4V[a\x0B\x08` `\x1F\x19`\x1F\x84\x01\x16\x01a\nJV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0B\x1CW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0BQW__\xFD[\x855a\x0B\\\x81a\t\xD0V[\x94P` \x86\x015\x93P`@\x86\x015a\x0Bs\x81a\t\xD0V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0B\xA4W__\xFD[Pa\x0B\xADa\n!V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\xD2W__\xFD[Pa\x0B\xDBa\n!V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xF5W__\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[\x81\x81\x03\x81\x81\x11\x15a\x0C^<#\x14a\x01VW[__\xFD[a\x01!a\x02DV[\0[a\x01+a\x03\nV[`@Qa\x018\x91\x90a\x13\xBEV[`@Q\x80\x91\x03\x90\xF3[a\x01Ia\x03jV[`@Qa\x018\x91\x90a\x147V[a\x01+a\x04\xA6V[a\x01+a\x05\x04V[a\x01na\x05bV[`@Qa\x018\x91\x90a\x15zV[a\x01\x84` T\x81V[`@Q\x90\x81R` \x01a\x018V[a\x01\x9Aa\x06\xDBV[`@Qa\x018\x91\x90a\x15\xF8V[a\x01!a\x07\xA6V[a\x01\xB7a\r\rV[`@Qa\x018\x91\x90a\x16OV[a\x01\xB7a\x0E\x03V[a\x01\x9Aa\x0E\xF9V[a\x01\xDCa\x0F\xC4V[`@Q\x90\x15\x15\x81R` \x01a\x018V[a\x01+a\x10\x94V[a\x01!a\x02\x026`\x04a\x16\xE1V[a\x10\xF2V[`\x1FTa\x01\xDC\x90`\xFF\x16\x81V[`\x1FTa\x02,\x90a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x018V[a\x02}b\xD5\x9F\x80sJ\x1D\xF9qaG\xB7\x85\xF3\xF8 \x19\xF3o$\x8A\xC1]\xC3\x08s\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E` Ta\x10\xF2V[`\"T`!T`@Q`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x92\x90\x91\x16\x90a\x02\x9F\x90a\x13\xB1V[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x02\xCFW=__>=_\xFD[P`#\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`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03`W` \x02\x82\x01\x91\x90_R` _ \x90[\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03BW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\x86W\x83\x82\x90_R` _ \x01\x80Ta\x03\xFB\x90a\x17\"V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x04'\x90a\x17\"V[\x80\x15a\x04rW\x80`\x1F\x10a\x04IWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x04rV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x04UW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03\xDEV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x03\x8DV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03`W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03BWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03`W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03BWPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x05\xB5\x90a\x17\"V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05\xE1\x90a\x17\"V[\x80\x15a\x06,W\x80`\x1F\x10a\x06\x03Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x06,V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x06\x0FW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06\xC3W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x06pW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05\x85V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW\x83\x82\x90_R` _ \x01\x80Ta\x07\x1B\x90a\x17\"V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07G\x90a\x17\"V[\x80\x15a\x07\x92W\x80`\x1F\x10a\x07iWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07\x92V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07uW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x06\xFEV[`\x1FT`@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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R_\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x1EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08B\x91\x90a\x17sV[`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\xBBW__\xFD[PZ\xF1\x15\x80\x15a\x08\xCDW=__>=_\xFD[PP`\x1FT`#T` T`@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\x81R`\x01`\x01`\xA0\x1B\x03\x92\x83\x16`\x04\x82\x01R`$\x81\x01\x91\x90\x91Ra\x01\0\x90\x92\x04\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\tEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\ti\x91\x90a\x17\x8AV[P`#T`@Q\x7F\x86\xB9b\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\x81R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x86\xB9b\r\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t\xD9W__\xFD[PZ\xF1\x15\x80\x15a\t\xEBW=__>=_\xFD[PP`\"T` \x80T`@\x80Q`\x01`\x01`\xA0\x1B\x03\x90\x94\x16\x84R\x91\x83\x01R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x93P\x01\x90P`@Q\x80\x91\x03\x90\xA1`#T`\x1FT` \x80T`@\x80Q\x92\x83\x01\x81R_\x83RQ\x7F\x7F\x81O5\0\0\0\0\0\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\x03a\x01\0\x90\x94\x04\x84\x16`\x04\x82\x01R`$\x81\x01\x91\x90\x91R`\x01`D\x82\x01R\x90Q`d\x82\x01R\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\n\xBFW__\xFD[PZ\xF1\x15\x80\x15a\n\xD1W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0B!W__\xFD[PZ\xF1\x15\x80\x15a\x0B3W=__>=_\xFD[PP`\"T`@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\x81R`\x01`\x04\x82\x01Ra\x0B\xC7\x93P`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0B\x9BW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\xBF\x91\x90a\x17sV[` Ta\x13.V[`\"T`#T`@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\x81R`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x04\x82\x01Ra\x0CZ\x92\x91\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0C0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0CT\x91\x90a\x17sV[_a\x13.V[`\x1FT`@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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01Ra\r\n\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0C\xD4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C\xF8\x91\x90a\x17sV[` Ta\r\x05\x90\x84a\x17\xB0V[a\x13.V[PV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\xEBW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\x98W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\r0V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0E\xE1W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0E\x8EW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0E&V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x9DW\x83\x82\x90_R` _ \x01\x80Ta\x0F9\x90a\x17\"V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0Fe\x90a\x17\"V[\x80\x15a\x0F\xB0W\x80`\x1F\x10a\x0F\x87Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0F\xB0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\x93W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0F\x1CV[`\x08T_\x90`\xFF\x16\x15a\x0F\xDBWP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10iW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\x8D\x91\x90a\x17sV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x03`W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x03BWPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\x8DW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x11\xB4\x91\x90\x81\x01\x90a\x18\x1BV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x11\xD2\x92\x91\x90a\x18\xCFV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11\xEEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\x12\x91\x90a\x17sV[P`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12~W__\xFD[PZ\xF1\x15\x80\x15a\x12\x90W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x13\x03W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13'\x91\x90a\x17\x8AV[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x13\x97W__\xFD[PZ\xFA\x15\x80\x15a\x13\xA9W=__>=_\xFD[PPPPPPV[a\r\xD2\x80a\x18\xF1\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x13\xFEW\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x13\xD7V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x12W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`\x01`\x01`\xA0\x1B\x03\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x14\xF8W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x14\xE2\x84\x86Qa\x14\tV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x14\xA8V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x14]V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x15pW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x150V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x12W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x15\xC6`@\x88\x01\x82a\x14\tV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x15\xE1\x81\x83a\x15\x1EV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\xA0V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x12W`?\x19\x87\x86\x03\x01\x84Ra\x16:\x85\x83Qa\x14\tV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16\x1EV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\x12W`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x16\xB0`@\x87\x01\x82a\x15\x1EV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16uV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x16\xDCW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x16\xF4W__\xFD[\x845\x93Pa\x17\x04` \x86\x01a\x16\xC6V[\x92Pa\x17\x12`@\x86\x01a\x16\xC6V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x176W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x17mW\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17\x83W__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a\x17\x9AW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x17\xA9W__\xFD[\x93\x92PPPV[\x81\x81\x03\x81\x81\x11\x15a\x17\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`\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x18+W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18AW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x18QW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18kWa\x18ka\x17\xEEV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x18\x9BWa\x18\x9Ba\x17\xEEV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x18\xB2W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x18\xE1`@\x83\x01\x85a\x14\tV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\xD28\x03\x80a\r\xD2\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\xF5a\0\xDD_9_\x81\x81`h\x01Ra\x02\x87\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xC1\x01R\x81\x81a\x03\x0F\x01R\x81\x81a\x03}\x01Ra\x04\xB8\x01Ra\x0C\xF5_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cPcL\x0E\x14a\0NW\x80cW\xED\xABN\x14a\0cW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xF3\xB9w\x84\x14a\0\xC6W[__\xFD[a\0aa\0\\6`\x04a\n{V[a\0\xEDV[\0[a\0\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\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\0aa\0\xC16`\x04a\x0B=V[a\x01\x17V[a\0\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\x81V[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\xC1V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x16V[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\xDAV[`@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\x83\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0B\xE5V[\x82Q`@Q\x7F\x0E\xFEj\x8B\0\0\0\0\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`$\x82\x01\x88\x90R`D\x82\x01\x92\x90\x92R\x91\x92P_\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\x90\x91\x16\x90c\x0E\xFEj\x8B\x90`d\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02\xCFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xF3\x91\x90a\x0B\xE5V[\x90Pa\x036s\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\x83a\x06\xD5V[`@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_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\xC4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xE8\x91\x90a\x0B\xE5V[\x90P\x82\x81\x11a\x04>W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[_a\x04I\x84\x83a\x0C)V[\x85Q\x90\x91P\x81\x10\x15a\x04\x9DW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x045V[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\xD4\x90\x85\x90\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\x90`\x84\x01[`@\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\x070V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06NW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06r\x91\x90a\x0B\xE5V[a\x06|\x91\x90a\x0CBV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\xD4\x90\x85\x90\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\x90`d\x01a\x05pV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07+\x90\x84\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\x90`d\x01a\x05pV[PPPV[_a\x07\x91\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\x08!\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07+W\x80\x80` \x01\x90Q\x81\x01\x90a\x07\xAF\x91\x90a\x0CUV[a\x07+W`@QbF\x1B\xCD`\xE5\x1B\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\x045V[``a\x08/\x84\x84_\x85a\x089V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08\xB1W`@QbF\x1B\xCD`\xE5\x1B\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\x045V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\x15W`@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\x045V[__\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\t=\x91\x90a\x0CtV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\twW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t|V[``\x91P[P\x91P\x91Pa\t\x8C\x82\x82\x86a\t\x97V[\x97\x96PPPPPPPV[``\x83\x15a\t\xA6WP\x81a\x082V[\x82Q\x15a\t\xB6W\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x045\x91\x90a\x0C\x8AV[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\t\xF1W__\xFD[PV[\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\nDWa\nDa\t\xF4V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\nsWa\nsa\t\xF4V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\n\x8EW__\xFD[\x845a\n\x99\x81a\t\xD0V[\x93P` \x85\x015\x92P`@\x85\x015a\n\xB0\x81a\t\xD0V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xCBW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\xDBW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xF5Wa\n\xF5a\t\xF4V[a\x0B\x08` `\x1F\x19`\x1F\x84\x01\x16\x01a\nJV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0B\x1CW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0BQW__\xFD[\x855a\x0B\\\x81a\t\xD0V[\x94P` \x86\x015\x93P`@\x86\x015a\x0Bs\x81a\t\xD0V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0B\xA4W__\xFD[Pa\x0B\xADa\n!V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\xD2W__\xFD[Pa\x0B\xDBa\n!V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xF5W__\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[\x81\x81\x03\x81\x81\x11\x15a\x0C = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - tokenReceived: data.0, - amountOut: data.1, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.tokenReceived, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountOut), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 TokenOutput { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&TokenOutput> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. -```solidity -event log(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `amountIn()` and selector `0x6bed55a6`. -```solidity -function amountIn() external view returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct amountInCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`amountIn()`](amountInCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct amountInReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: amountInCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for amountInCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: amountInReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for amountInReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for amountInCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "amountIn()"; - const SELECTOR: [u8; 4] = [107u8, 237u8, 85u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: amountInReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: amountInReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `setUp()` and selector `0x0a9254e4`. -```solidity -function setUp() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setUpCall; - ///Container type for the return parameters of the [`setUp()`](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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl setUpReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for setUpCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = setUpReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "setUp()"; - const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - setUpReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. -```solidity -function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferCall { - #[allow(missing_docs)] - pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub sender: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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::Uint<256>, - ); - #[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::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferCall) -> Self { - (value.forkAtBlock, value.sender, value.receiver, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - forkAtBlock: tuple.0, - sender: tuple.1, - receiver: tuple.2, - amount: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl simulateForkAndTransferReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for simulateForkAndTransferCall { - type Parameters<'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::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = simulateForkAndTransferReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; - const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), - ::tokenize( - &self.sender, - ), - ::tokenize( - &self.receiver, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - simulateForkAndTransferReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testDepositToVault()` and selector `0x8c193861`. -```solidity -function testDepositToVault() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testDepositToVaultCall; - ///Container type for the return parameters of the [`testDepositToVault()`](testDepositToVaultCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testDepositToVaultReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testDepositToVaultCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testDepositToVaultCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testDepositToVaultReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testDepositToVaultReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testDepositToVaultReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testDepositToVaultCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testDepositToVaultReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testDepositToVault()"; - const SELECTOR: [u8; 4] = [140u8, 25u8, 56u8, 97u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testDepositToVaultReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `token()` and selector `0xfc0c546a`. -```solidity -function token() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`token()`](tokenCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for tokenCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "token()"; - const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`HybridBTCStrategyForkedWbtc`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum HybridBTCStrategyForkedWbtcCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - amountIn(amountInCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - setUp(setUpCall), - #[allow(missing_docs)] - simulateForkAndTransfer(simulateForkAndTransferCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - testDepositToVault(testDepositToVaultCall), - #[allow(missing_docs)] - token(tokenCall), - } - #[automatically_derived] - impl HybridBTCStrategyForkedWbtcCalls { - /// 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]] = &[ - [10u8, 146u8, 84u8, 228u8], - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [102u8, 217u8, 169u8, 160u8], - [107u8, 237u8, 85u8, 166u8], - [133u8, 34u8, 108u8, 129u8], - [140u8, 25u8, 56u8, 97u8], - [145u8, 106u8, 23u8, 198u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [226u8, 12u8, 159u8, 113u8], - [249u8, 206u8, 14u8, 90u8], - [250u8, 118u8, 38u8, 212u8], - [252u8, 12u8, 84u8, 106u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for HybridBTCStrategyForkedWbtcCalls { - const NAME: &'static str = "HybridBTCStrategyForkedWbtcCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 17usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::amountIn(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::setUp(_) => ::SELECTOR, - Self::simulateForkAndTransfer(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::testDepositToVault(_) => { - ::SELECTOR - } - Self::token(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(HybridBTCStrategyForkedWbtcCalls::setUp) - } - setUp - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::targetContracts) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - HybridBTCStrategyForkedWbtcCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn amountIn( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(HybridBTCStrategyForkedWbtcCalls::amountIn) - } - amountIn - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn testDepositToVault( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::testDepositToVault) - } - testDepositToVault - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(HybridBTCStrategyForkedWbtcCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - HybridBTCStrategyForkedWbtcCalls::simulateForkAndTransfer, - ) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(HybridBTCStrategyForkedWbtcCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(HybridBTCStrategyForkedWbtcCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::setUp) - } - setUp - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::targetContracts) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - HybridBTCStrategyForkedWbtcCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn amountIn( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::amountIn) - } - amountIn - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn testDepositToVault( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::testDepositToVault) - } - testDepositToVault - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - HybridBTCStrategyForkedWbtcCalls::simulateForkAndTransfer, - ) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(HybridBTCStrategyForkedWbtcCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::amountIn(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::setUp(inner) => { - ::abi_encoded_size(inner) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testDepositToVault(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::token(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::amountIn(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::setUp(inner) => { - ::abi_encode_raw(inner, out) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testDepositToVault(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::token(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - ///Container for all the [`HybridBTCStrategyForkedWbtc`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum HybridBTCStrategyForkedWbtcEvents { - #[allow(missing_docs)] - TokenOutput(TokenOutput), - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl HybridBTCStrategyForkedWbtcEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for HybridBTCStrategyForkedWbtcEvents { - const NAME: &'static str = "HybridBTCStrategyForkedWbtcEvents"; - const COUNT: usize = 23usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::TokenOutput) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 HybridBTCStrategyForkedWbtcEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`HybridBTCStrategyForkedWbtc`](self) contract instance. - -See the [wrapper's documentation](`HybridBTCStrategyForkedWbtcInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> HybridBTCStrategyForkedWbtcInstance { - HybridBTCStrategyForkedWbtcInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - HybridBTCStrategyForkedWbtcInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - HybridBTCStrategyForkedWbtcInstance::::deploy_builder(provider) - } - /**A [`HybridBTCStrategyForkedWbtc`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`HybridBTCStrategyForkedWbtc`](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 HybridBTCStrategyForkedWbtcInstance< - P, - N = alloy_contract::private::Ethereum, - > { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for HybridBTCStrategyForkedWbtcInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("HybridBTCStrategyForkedWbtcInstance") - .field(&self.address) - .finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > HybridBTCStrategyForkedWbtcInstance { - /**Creates a new wrapper around an on-chain [`HybridBTCStrategyForkedWbtc`](self) contract instance. - -See the [wrapper's documentation](`HybridBTCStrategyForkedWbtcInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 HybridBTCStrategyForkedWbtcInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> HybridBTCStrategyForkedWbtcInstance { - HybridBTCStrategyForkedWbtcInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > HybridBTCStrategyForkedWbtcInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`amountIn`] function. - pub fn amountIn(&self) -> alloy_contract::SolCallBuilder<&P, amountInCall, N> { - self.call_builder(&amountInCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`setUp`] function. - pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { - self.call_builder(&setUpCall) - } - ///Creates a new call builder for the [`simulateForkAndTransfer`] function. - pub fn simulateForkAndTransfer( - &self, - forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - sender: alloy::sol_types::private::Address, - receiver: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { - self.call_builder( - &simulateForkAndTransferCall { - forkAtBlock, - sender, - receiver, - amount, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`testDepositToVault`] function. - pub fn testDepositToVault( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testDepositToVaultCall, N> { - self.call_builder(&testDepositToVaultCall) - } - ///Creates a new call builder for the [`token`] function. - pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { - self.call_builder(&tokenCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > HybridBTCStrategyForkedWbtcInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`TokenOutput`] event. - pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/i_avalon_i_pool.rs b/crates/bindings/src/i_avalon_i_pool.rs deleted file mode 100644 index ae56844c8..000000000 --- a/crates/bindings/src/i_avalon_i_pool.rs +++ /dev/null @@ -1,808 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface IAvalonIPool { - function supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external; - function withdraw(address asset, uint256 amount, address to) external returns (uint256); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "supply", - "inputs": [ - { - "name": "asset", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "onBehalfOf", - "type": "address", - "internalType": "address" - }, - { - "name": "referralCode", - "type": "uint16", - "internalType": "uint16" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "withdraw", - "inputs": [ - { - "name": "asset", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "to", - "type": "address", - "internalType": "address" - } - ], - "outputs": [ - { - "name": "", - "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 IAvalonIPool { - use super::*; - use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `supply(address,uint256,address,uint16)` and selector `0x617ba037`. -```solidity -function supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct supplyCall { - #[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 onBehalfOf: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub referralCode: u16, - } - ///Container type for the return parameters of the [`supply(address,uint256,address,uint16)`](supplyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct supplyReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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<16>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::primitives::aliases::U256, - alloy::sol_types::private::Address, - u16, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: supplyCall) -> Self { - (value.asset, value.amount, value.onBehalfOf, value.referralCode) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for supplyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - asset: tuple.0, - amount: tuple.1, - onBehalfOf: tuple.2, - referralCode: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: supplyReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for supplyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl supplyReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for supplyCall { - 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<16>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = supplyReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "supply(address,uint256,address,uint16)"; - const SELECTOR: [u8; 4] = [97u8, 123u8, 160u8, 55u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.asset, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ::tokenize( - &self.onBehalfOf, - ), - as alloy_sol_types::SolType>::tokenize(&self.referralCode), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - supplyReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `withdraw(address,uint256,address)` and selector `0x69328dec`. -```solidity -function withdraw(address asset, uint256 amount, address to) external returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct withdrawCall { - #[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 to: alloy::sol_types::private::Address, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`withdraw(address,uint256,address)`](withdrawCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct withdrawReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: withdrawCall) -> Self { - (value.asset, value.amount, value.to) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for withdrawCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - asset: tuple.0, - amount: tuple.1, - to: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: withdrawReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for withdrawReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[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::Address, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "withdraw(address,uint256,address)"; - const SELECTOR: [u8; 4] = [105u8, 50u8, 141u8, 236u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.asset, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ::tokenize( - &self.to, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: withdrawReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: withdrawReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`IAvalonIPool`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum IAvalonIPoolCalls { - #[allow(missing_docs)] - supply(supplyCall), - #[allow(missing_docs)] - withdraw(withdrawCall), - } - #[automatically_derived] - impl IAvalonIPoolCalls { - /// 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]] = &[ - [97u8, 123u8, 160u8, 55u8], - [105u8, 50u8, 141u8, 236u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for IAvalonIPoolCalls { - const NAME: &'static str = "IAvalonIPoolCalls"; - const MIN_DATA_LENGTH: usize = 96usize; - const COUNT: usize = 2usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::supply(_) => ::SELECTOR, - Self::withdraw(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn supply( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IAvalonIPoolCalls::supply) - } - supply - }, - { - fn withdraw( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IAvalonIPoolCalls::withdraw) - } - withdraw - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn supply( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IAvalonIPoolCalls::supply) - } - supply - }, - { - fn withdraw( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IAvalonIPoolCalls::withdraw) - } - withdraw - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::supply(inner) => { - ::abi_encoded_size(inner) - } - Self::withdraw(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::supply(inner) => { - ::abi_encode_raw(inner, out) - } - Self::withdraw(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`IAvalonIPool`](self) contract instance. - -See the [wrapper's documentation](`IAvalonIPoolInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> IAvalonIPoolInstance { - IAvalonIPoolInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - IAvalonIPoolInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - IAvalonIPoolInstance::::deploy_builder(provider) - } - /**A [`IAvalonIPool`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`IAvalonIPool`](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 IAvalonIPoolInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for IAvalonIPoolInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("IAvalonIPoolInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IAvalonIPoolInstance { - /**Creates a new wrapper around an on-chain [`IAvalonIPool`](self) contract instance. - -See the [wrapper's documentation](`IAvalonIPoolInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 IAvalonIPoolInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> IAvalonIPoolInstance { - IAvalonIPoolInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IAvalonIPoolInstance { - /// 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( - &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 [`supply`] function. - pub fn supply( - &self, - asset: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - onBehalfOf: alloy::sol_types::private::Address, - referralCode: u16, - ) -> alloy_contract::SolCallBuilder<&P, supplyCall, N> { - self.call_builder( - &supplyCall { - asset, - amount, - onBehalfOf, - referralCode, - }, - ) - } - ///Creates a new call builder for the [`withdraw`] function. - pub fn withdraw( - &self, - asset: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - to: alloy::sol_types::private::Address, - ) -> alloy_contract::SolCallBuilder<&P, withdrawCall, N> { - self.call_builder(&withdrawCall { asset, amount, to }) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IAvalonIPoolInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/i_bedrock_vault.rs b/crates/bindings/src/i_bedrock_vault.rs deleted file mode 100644 index 693007172..000000000 --- a/crates/bindings/src/i_bedrock_vault.rs +++ /dev/null @@ -1,924 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface IBedrockVault { - function mint(address _token, uint256 _amount) external; - function redeem(address _token, uint256 _amount) external; - function uniBTC() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "mint", - "inputs": [ - { - "name": "_token", - "type": "address", - "internalType": "address" - }, - { - "name": "_amount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "redeem", - "inputs": [ - { - "name": "_token", - "type": "address", - "internalType": "address" - }, - { - "name": "_amount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "uniBTC", - "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 IBedrockVault { - use super::*; - use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `mint(address,uint256)` and selector `0x40c10f19`. -```solidity -function mint(address _token, uint256 _amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct mintCall { - #[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 [`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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: mintCall) -> Self { - (value._token, value._amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for mintCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - _token: tuple.0, - _amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: mintReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for mintReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl mintReturn { - fn _tokenize( - &self, - ) -> ::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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = mintReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "mint(address,uint256)"; - const SELECTOR: [u8; 4] = [64u8, 193u8, 15u8, 25u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._token, - ), - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `redeem(address,uint256)` and selector `0x1e9a6950`. -```solidity -function redeem(address _token, uint256 _amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct redeemCall { - #[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 [`redeem(address,uint256)`](redeemCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct redeemReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: redeemCall) -> Self { - (value._token, value._amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for redeemCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - _token: tuple.0, - _amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: redeemReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for redeemReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl redeemReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for redeemCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = redeemReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "redeem(address,uint256)"; - const SELECTOR: [u8; 4] = [30u8, 154u8, 105u8, 80u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._token, - ), - as alloy_sol_types::SolType>::tokenize(&self._amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - redeemReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `uniBTC()` and selector `0x59f3d39b`. -```solidity -function uniBTC() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct uniBTCCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`uniBTC()`](uniBTCCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct uniBTCReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: uniBTCCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for uniBTCCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: uniBTCReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for uniBTCReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for uniBTCCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "uniBTC()"; - const SELECTOR: [u8; 4] = [89u8, 243u8, 211u8, 155u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: uniBTCReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: uniBTCReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`IBedrockVault`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum IBedrockVaultCalls { - #[allow(missing_docs)] - mint(mintCall), - #[allow(missing_docs)] - redeem(redeemCall), - #[allow(missing_docs)] - uniBTC(uniBTCCall), - } - #[automatically_derived] - impl IBedrockVaultCalls { - /// 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]] = &[ - [30u8, 154u8, 105u8, 80u8], - [64u8, 193u8, 15u8, 25u8], - [89u8, 243u8, 211u8, 155u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for IBedrockVaultCalls { - const NAME: &'static str = "IBedrockVaultCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 3usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::mint(_) => ::SELECTOR, - Self::redeem(_) => ::SELECTOR, - Self::uniBTC(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn redeem( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IBedrockVaultCalls::redeem) - } - redeem - }, - { - fn mint(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IBedrockVaultCalls::mint) - } - mint - }, - { - fn uniBTC( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IBedrockVaultCalls::uniBTC) - } - uniBTC - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn redeem( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IBedrockVaultCalls::redeem) - } - redeem - }, - { - fn mint(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IBedrockVaultCalls::mint) - } - mint - }, - { - fn uniBTC( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IBedrockVaultCalls::uniBTC) - } - uniBTC - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::mint(inner) => { - ::abi_encoded_size(inner) - } - Self::redeem(inner) => { - ::abi_encoded_size(inner) - } - Self::uniBTC(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::mint(inner) => { - ::abi_encode_raw(inner, out) - } - Self::redeem(inner) => { - ::abi_encode_raw(inner, out) - } - Self::uniBTC(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`IBedrockVault`](self) contract instance. - -See the [wrapper's documentation](`IBedrockVaultInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> IBedrockVaultInstance { - IBedrockVaultInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - IBedrockVaultInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - IBedrockVaultInstance::::deploy_builder(provider) - } - /**A [`IBedrockVault`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`IBedrockVault`](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 IBedrockVaultInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for IBedrockVaultInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("IBedrockVaultInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IBedrockVaultInstance { - /**Creates a new wrapper around an on-chain [`IBedrockVault`](self) contract instance. - -See the [wrapper's documentation](`IBedrockVaultInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 IBedrockVaultInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> IBedrockVaultInstance { - IBedrockVaultInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IBedrockVaultInstance { - /// 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( - &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 [`mint`] function. - pub fn mint( - &self, - _token: alloy::sol_types::private::Address, - _amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> { - self.call_builder(&mintCall { _token, _amount }) - } - ///Creates a new call builder for the [`redeem`] function. - pub fn redeem( - &self, - _token: alloy::sol_types::private::Address, - _amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, redeemCall, N> { - self.call_builder(&redeemCall { _token, _amount }) - } - ///Creates a new call builder for the [`uniBTC`] function. - pub fn uniBTC(&self) -> alloy_contract::SolCallBuilder<&P, uniBTCCall, N> { - self.call_builder(&uniBTCCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IBedrockVaultInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/i_ionic_token.rs b/crates/bindings/src/i_ionic_token.rs deleted file mode 100644 index 827cacfe4..000000000 --- a/crates/bindings/src/i_ionic_token.rs +++ /dev/null @@ -1,719 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface IIonicToken { - function mint(uint256 mintAmount) external returns (uint256); - function redeem(uint256 redeemTokens) external returns (uint256); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "mint", - "inputs": [ - { - "name": "mintAmount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "redeem", - "inputs": [ - { - "name": "redeemTokens", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "", - "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 IIonicToken { - use super::*; - use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `mint(uint256)` and selector `0xa0712d68`. -```solidity -function mint(uint256 mintAmount) external returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct mintCall { - #[allow(missing_docs)] - pub mintAmount: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`mint(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: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: mintCall) -> Self { - (value.mintAmount,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for mintCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { mintAmount: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: mintReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "mint(uint256)"; - const SELECTOR: [u8; 4] = [160u8, 113u8, 45u8, 104u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.mintAmount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: mintReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `redeem(uint256)` and selector `0xdb006a75`. -```solidity -function redeem(uint256 redeemTokens) external returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct redeemCall { - #[allow(missing_docs)] - pub redeemTokens: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`redeem(uint256)`](redeemCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct redeemReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: redeemCall) -> Self { - (value.redeemTokens,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for redeemCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { redeemTokens: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: redeemReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for redeemReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for redeemCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "redeem(uint256)"; - const SELECTOR: [u8; 4] = [219u8, 0u8, 106u8, 117u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.redeemTokens), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: redeemReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: redeemReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`IIonicToken`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum IIonicTokenCalls { - #[allow(missing_docs)] - mint(mintCall), - #[allow(missing_docs)] - redeem(redeemCall), - } - #[automatically_derived] - impl IIonicTokenCalls { - /// 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]] = &[ - [160u8, 113u8, 45u8, 104u8], - [219u8, 0u8, 106u8, 117u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for IIonicTokenCalls { - const NAME: &'static str = "IIonicTokenCalls"; - const MIN_DATA_LENGTH: usize = 32usize; - const COUNT: usize = 2usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::mint(_) => ::SELECTOR, - Self::redeem(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn mint(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IIonicTokenCalls::mint) - } - mint - }, - { - fn redeem(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IIonicTokenCalls::redeem) - } - redeem - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn mint(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IIonicTokenCalls::mint) - } - mint - }, - { - fn redeem(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IIonicTokenCalls::redeem) - } - redeem - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::mint(inner) => { - ::abi_encoded_size(inner) - } - Self::redeem(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::mint(inner) => { - ::abi_encode_raw(inner, out) - } - Self::redeem(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`IIonicToken`](self) contract instance. - -See the [wrapper's documentation](`IIonicTokenInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> IIonicTokenInstance { - IIonicTokenInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - IIonicTokenInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - IIonicTokenInstance::::deploy_builder(provider) - } - /**A [`IIonicToken`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`IIonicToken`](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 IIonicTokenInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for IIonicTokenInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("IIonicTokenInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IIonicTokenInstance { - /**Creates a new wrapper around an on-chain [`IIonicToken`](self) contract instance. - -See the [wrapper's documentation](`IIonicTokenInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 IIonicTokenInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> IIonicTokenInstance { - IIonicTokenInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IIonicTokenInstance { - /// 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( - &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 [`mint`] function. - pub fn mint( - &self, - mintAmount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> { - self.call_builder(&mintCall { mintAmount }) - } - ///Creates a new call builder for the [`redeem`] function. - pub fn redeem( - &self, - redeemTokens: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, redeemCall, N> { - self.call_builder(&redeemCall { redeemTokens }) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IIonicTokenInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/i_light_relay.rs b/crates/bindings/src/i_light_relay.rs deleted file mode 100644 index 81d0227a4..000000000 --- a/crates/bindings/src/i_light_relay.rs +++ /dev/null @@ -1,2550 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface ILightRelay { - event AuthorizationRequirementChanged(bool newStatus); - event Genesis(uint256 blockHeight); - event ProofLengthChanged(uint256 newLength); - event Retarget(uint256 oldDifficulty, uint256 newDifficulty); - event SubmitterAuthorized(address submitter); - event SubmitterDeauthorized(address submitter); - - function getBlockDifficulty(uint256 blockNumber) external view returns (uint256); - function getCurrentEpochDifficulty() external view returns (uint256); - function getPrevEpochDifficulty() external view returns (uint256); - function getRelayRange() external view returns (uint256 relayGenesis, uint256 currentEpochEnd); - function retarget(bytes memory headers) external; - function validateChain(bytes memory headers) external view returns (uint256 startingHeaderTimestamp, uint256 headerCount); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "getBlockDifficulty", - "inputs": [ - { - "name": "blockNumber", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getCurrentEpochDifficulty", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getPrevEpochDifficulty", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getRelayRange", - "inputs": [], - "outputs": [ - { - "name": "relayGenesis", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "currentEpochEnd", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "retarget", - "inputs": [ - { - "name": "headers", - "type": "bytes", - "internalType": "bytes" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "validateChain", - "inputs": [ - { - "name": "headers", - "type": "bytes", - "internalType": "bytes" - } - ], - "outputs": [ - { - "name": "startingHeaderTimestamp", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "headerCount", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "AuthorizationRequirementChanged", - "inputs": [ - { - "name": "newStatus", - "type": "bool", - "indexed": false, - "internalType": "bool" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "Genesis", - "inputs": [ - { - "name": "blockHeight", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "ProofLengthChanged", - "inputs": [ - { - "name": "newLength", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "Retarget", - "inputs": [ - { - "name": "oldDifficulty", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "newDifficulty", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "SubmitterAuthorized", - "inputs": [ - { - "name": "submitter", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "SubmitterDeauthorized", - "inputs": [ - { - "name": "submitter", - "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 ILightRelay { - use super::*; - use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `AuthorizationRequirementChanged(bool)` and selector `0xd813b248d49c8bf08be2b6947126da6763df310beed7bea97756456c5727419a`. -```solidity -event AuthorizationRequirementChanged(bool newStatus); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct AuthorizationRequirementChanged { - #[allow(missing_docs)] - pub newStatus: bool, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for AuthorizationRequirementChanged { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "AuthorizationRequirementChanged(bool)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 216u8, 19u8, 178u8, 72u8, 212u8, 156u8, 139u8, 240u8, 139u8, 226u8, - 182u8, 148u8, 113u8, 38u8, 218u8, 103u8, 99u8, 223u8, 49u8, 11u8, 238u8, - 215u8, 190u8, 169u8, 119u8, 86u8, 69u8, 108u8, 87u8, 39u8, 65u8, 154u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { newStatus: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.newStatus, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 AuthorizationRequirementChanged { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&AuthorizationRequirementChanged> - for alloy_sol_types::private::LogData { - #[inline] - fn from( - this: &AuthorizationRequirementChanged, - ) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `Genesis(uint256)` and selector `0x2381d16925551c2fb1a5edfcf4fce2f6d085e1f85f4b88340c09c9d191f9d4e9`. -```solidity -event Genesis(uint256 blockHeight); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct Genesis { - #[allow(missing_docs)] - pub blockHeight: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for Genesis { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "Genesis(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 129u8, 209u8, 105u8, 37u8, 85u8, 28u8, 47u8, 177u8, 165u8, 237u8, - 252u8, 244u8, 252u8, 226u8, 246u8, 208u8, 133u8, 225u8, 248u8, 95u8, - 75u8, 136u8, 52u8, 12u8, 9u8, 201u8, 209u8, 145u8, 249u8, 212u8, 233u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { blockHeight: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.blockHeight), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 Genesis { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&Genesis> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &Genesis) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `ProofLengthChanged(uint256)` and selector `0x3e9f904d8cf11753c79b67c8259c582056d4a7d8af120f81257a59eeb8824b96`. -```solidity -event ProofLengthChanged(uint256 newLength); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct ProofLengthChanged { - #[allow(missing_docs)] - pub newLength: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for ProofLengthChanged { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "ProofLengthChanged(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 62u8, 159u8, 144u8, 77u8, 140u8, 241u8, 23u8, 83u8, 199u8, 155u8, 103u8, - 200u8, 37u8, 156u8, 88u8, 32u8, 86u8, 212u8, 167u8, 216u8, 175u8, 18u8, - 15u8, 129u8, 37u8, 122u8, 89u8, 238u8, 184u8, 130u8, 75u8, 150u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { newLength: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.newLength), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 ProofLengthChanged { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&ProofLengthChanged> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &ProofLengthChanged) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `Retarget(uint256,uint256)` and selector `0xa282ee798b132f9dc11e06cd4d8e767e562be8709602ca14fea7ab3392acbdab`. -```solidity -event Retarget(uint256 oldDifficulty, uint256 newDifficulty); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct Retarget { - #[allow(missing_docs)] - pub oldDifficulty: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub newDifficulty: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for Retarget { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "Retarget(uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 162u8, 130u8, 238u8, 121u8, 139u8, 19u8, 47u8, 157u8, 193u8, 30u8, 6u8, - 205u8, 77u8, 142u8, 118u8, 126u8, 86u8, 43u8, 232u8, 112u8, 150u8, 2u8, - 202u8, 20u8, 254u8, 167u8, 171u8, 51u8, 146u8, 172u8, 189u8, 171u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - oldDifficulty: data.0, - newDifficulty: data.1, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.oldDifficulty), - as alloy_sol_types::SolType>::tokenize(&self.newDifficulty), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 Retarget { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&Retarget> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &Retarget) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `SubmitterAuthorized(address)` and selector `0xd53649b492f738bb59d6825099b5955073efda0bf9e3a7ad20da22e110122e29`. -```solidity -event SubmitterAuthorized(address submitter); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct SubmitterAuthorized { - #[allow(missing_docs)] - pub submitter: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for SubmitterAuthorized { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "SubmitterAuthorized(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 213u8, 54u8, 73u8, 180u8, 146u8, 247u8, 56u8, 187u8, 89u8, 214u8, 130u8, - 80u8, 153u8, 181u8, 149u8, 80u8, 115u8, 239u8, 218u8, 11u8, 249u8, 227u8, - 167u8, 173u8, 32u8, 218u8, 34u8, 225u8, 16u8, 18u8, 46u8, 41u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { submitter: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.submitter, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 SubmitterAuthorized { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&SubmitterAuthorized> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &SubmitterAuthorized) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `SubmitterDeauthorized(address)` and selector `0x7498b96beeabea5ad3139f1a2861a03e480034254e36b10aae2e6e42ad7b4b68`. -```solidity -event SubmitterDeauthorized(address submitter); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct SubmitterDeauthorized { - #[allow(missing_docs)] - pub submitter: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for SubmitterDeauthorized { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "SubmitterDeauthorized(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 116u8, 152u8, 185u8, 107u8, 238u8, 171u8, 234u8, 90u8, 211u8, 19u8, - 159u8, 26u8, 40u8, 97u8, 160u8, 62u8, 72u8, 0u8, 52u8, 37u8, 78u8, 54u8, - 177u8, 10u8, 174u8, 46u8, 110u8, 66u8, 173u8, 123u8, 75u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { submitter: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.submitter, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 SubmitterDeauthorized { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&SubmitterDeauthorized> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &SubmitterDeauthorized) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getBlockDifficulty(uint256)` and selector `0x06a27422`. -```solidity -function getBlockDifficulty(uint256 blockNumber) external view returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getBlockDifficultyCall { - #[allow(missing_docs)] - pub blockNumber: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getBlockDifficulty(uint256)`](getBlockDifficultyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getBlockDifficultyReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getBlockDifficultyCall) -> Self { - (value.blockNumber,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getBlockDifficultyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { blockNumber: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getBlockDifficultyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getBlockDifficultyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getBlockDifficultyCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getBlockDifficulty(uint256)"; - const SELECTOR: [u8; 4] = [6u8, 162u8, 116u8, 34u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.blockNumber), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getBlockDifficultyReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getBlockDifficultyReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getCurrentEpochDifficulty()` and selector `0x113764be`. -```solidity -function getCurrentEpochDifficulty() external view returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getCurrentEpochDifficultyCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getCurrentEpochDifficulty()`](getCurrentEpochDifficultyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getCurrentEpochDifficultyReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getCurrentEpochDifficultyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getCurrentEpochDifficultyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getCurrentEpochDifficultyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getCurrentEpochDifficultyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getCurrentEpochDifficultyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getCurrentEpochDifficulty()"; - const SELECTOR: [u8; 4] = [17u8, 55u8, 100u8, 190u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getCurrentEpochDifficultyReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getCurrentEpochDifficultyReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getPrevEpochDifficulty()` and selector `0x2b97be24`. -```solidity -function getPrevEpochDifficulty() external view returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getPrevEpochDifficultyCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getPrevEpochDifficulty()`](getPrevEpochDifficultyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getPrevEpochDifficultyReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getPrevEpochDifficultyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getPrevEpochDifficultyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getPrevEpochDifficultyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getPrevEpochDifficultyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getPrevEpochDifficultyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getPrevEpochDifficulty()"; - const SELECTOR: [u8; 4] = [43u8, 151u8, 190u8, 36u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getPrevEpochDifficultyReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getPrevEpochDifficultyReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getRelayRange()` and selector `0x10b76ed8`. -```solidity -function getRelayRange() external view returns (uint256 relayGenesis, uint256 currentEpochEnd); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getRelayRangeCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getRelayRange()`](getRelayRangeCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getRelayRangeReturn { - #[allow(missing_docs)] - pub relayGenesis: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub currentEpochEnd: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getRelayRangeCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getRelayRangeCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getRelayRangeReturn) -> Self { - (value.relayGenesis, value.currentEpochEnd) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getRelayRangeReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - relayGenesis: tuple.0, - currentEpochEnd: tuple.1, - } - } - } - } - impl getRelayRangeReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.relayGenesis), - as alloy_sol_types::SolType>::tokenize(&self.currentEpochEnd), - ) - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getRelayRangeCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = getRelayRangeReturn; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getRelayRange()"; - const SELECTOR: [u8; 4] = [16u8, 183u8, 110u8, 216u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - getRelayRangeReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `retarget(bytes)` and selector `0x7ca5b1dd`. -```solidity -function retarget(bytes memory headers) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct retargetCall { - #[allow(missing_docs)] - pub headers: alloy::sol_types::private::Bytes, - } - ///Container type for the return parameters of the [`retarget(bytes)`](retargetCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct retargetReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: retargetCall) -> Self { - (value.headers,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for retargetCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { headers: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: retargetReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for retargetReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl retargetReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for retargetCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Bytes,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = retargetReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "retarget(bytes)"; - const SELECTOR: [u8; 4] = [124u8, 165u8, 177u8, 221u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.headers, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - retargetReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `validateChain(bytes)` and selector `0x189179a3`. -```solidity -function validateChain(bytes memory headers) external view returns (uint256 startingHeaderTimestamp, uint256 headerCount); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct validateChainCall { - #[allow(missing_docs)] - pub headers: alloy::sol_types::private::Bytes, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`validateChain(bytes)`](validateChainCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct validateChainReturn { - #[allow(missing_docs)] - pub startingHeaderTimestamp: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub headerCount: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: validateChainCall) -> Self { - (value.headers,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for validateChainCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { headers: tuple.0 } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: validateChainReturn) -> Self { - (value.startingHeaderTimestamp, value.headerCount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for validateChainReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - startingHeaderTimestamp: tuple.0, - headerCount: tuple.1, - } - } - } - } - impl validateChainReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize( - &self.startingHeaderTimestamp, - ), - as alloy_sol_types::SolType>::tokenize(&self.headerCount), - ) - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for validateChainCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Bytes,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = validateChainReturn; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "validateChain(bytes)"; - const SELECTOR: [u8; 4] = [24u8, 145u8, 121u8, 163u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.headers, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - validateChainReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`ILightRelay`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum ILightRelayCalls { - #[allow(missing_docs)] - getBlockDifficulty(getBlockDifficultyCall), - #[allow(missing_docs)] - getCurrentEpochDifficulty(getCurrentEpochDifficultyCall), - #[allow(missing_docs)] - getPrevEpochDifficulty(getPrevEpochDifficultyCall), - #[allow(missing_docs)] - getRelayRange(getRelayRangeCall), - #[allow(missing_docs)] - retarget(retargetCall), - #[allow(missing_docs)] - validateChain(validateChainCall), - } - #[automatically_derived] - impl ILightRelayCalls { - /// 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, 162u8, 116u8, 34u8], - [16u8, 183u8, 110u8, 216u8], - [17u8, 55u8, 100u8, 190u8], - [24u8, 145u8, 121u8, 163u8], - [43u8, 151u8, 190u8, 36u8], - [124u8, 165u8, 177u8, 221u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for ILightRelayCalls { - const NAME: &'static str = "ILightRelayCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 6usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::getBlockDifficulty(_) => { - ::SELECTOR - } - Self::getCurrentEpochDifficulty(_) => { - ::SELECTOR - } - Self::getPrevEpochDifficulty(_) => { - ::SELECTOR - } - Self::getRelayRange(_) => { - ::SELECTOR - } - Self::retarget(_) => ::SELECTOR, - Self::validateChain(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getBlockDifficulty( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ILightRelayCalls::getBlockDifficulty) - } - getBlockDifficulty - }, - { - fn getRelayRange( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ILightRelayCalls::getRelayRange) - } - getRelayRange - }, - { - fn getCurrentEpochDifficulty( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ILightRelayCalls::getCurrentEpochDifficulty) - } - getCurrentEpochDifficulty - }, - { - fn validateChain( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ILightRelayCalls::validateChain) - } - validateChain - }, - { - fn getPrevEpochDifficulty( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ILightRelayCalls::getPrevEpochDifficulty) - } - getPrevEpochDifficulty - }, - { - fn retarget( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ILightRelayCalls::retarget) - } - retarget - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getBlockDifficulty( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ILightRelayCalls::getBlockDifficulty) - } - getBlockDifficulty - }, - { - fn getRelayRange( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ILightRelayCalls::getRelayRange) - } - getRelayRange - }, - { - fn getCurrentEpochDifficulty( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ILightRelayCalls::getCurrentEpochDifficulty) - } - getCurrentEpochDifficulty - }, - { - fn validateChain( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ILightRelayCalls::validateChain) - } - validateChain - }, - { - fn getPrevEpochDifficulty( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ILightRelayCalls::getPrevEpochDifficulty) - } - getPrevEpochDifficulty - }, - { - fn retarget( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ILightRelayCalls::retarget) - } - retarget - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::getBlockDifficulty(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getCurrentEpochDifficulty(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getPrevEpochDifficulty(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getRelayRange(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::retarget(inner) => { - ::abi_encoded_size(inner) - } - Self::validateChain(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::getBlockDifficulty(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getCurrentEpochDifficulty(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getPrevEpochDifficulty(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getRelayRange(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::retarget(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::validateChain(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`ILightRelay`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum ILightRelayEvents { - #[allow(missing_docs)] - AuthorizationRequirementChanged(AuthorizationRequirementChanged), - #[allow(missing_docs)] - Genesis(Genesis), - #[allow(missing_docs)] - ProofLengthChanged(ProofLengthChanged), - #[allow(missing_docs)] - Retarget(Retarget), - #[allow(missing_docs)] - SubmitterAuthorized(SubmitterAuthorized), - #[allow(missing_docs)] - SubmitterDeauthorized(SubmitterDeauthorized), - } - #[automatically_derived] - impl ILightRelayEvents { - /// 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]] = &[ - [ - 35u8, 129u8, 209u8, 105u8, 37u8, 85u8, 28u8, 47u8, 177u8, 165u8, 237u8, - 252u8, 244u8, 252u8, 226u8, 246u8, 208u8, 133u8, 225u8, 248u8, 95u8, - 75u8, 136u8, 52u8, 12u8, 9u8, 201u8, 209u8, 145u8, 249u8, 212u8, 233u8, - ], - [ - 62u8, 159u8, 144u8, 77u8, 140u8, 241u8, 23u8, 83u8, 199u8, 155u8, 103u8, - 200u8, 37u8, 156u8, 88u8, 32u8, 86u8, 212u8, 167u8, 216u8, 175u8, 18u8, - 15u8, 129u8, 37u8, 122u8, 89u8, 238u8, 184u8, 130u8, 75u8, 150u8, - ], - [ - 116u8, 152u8, 185u8, 107u8, 238u8, 171u8, 234u8, 90u8, 211u8, 19u8, - 159u8, 26u8, 40u8, 97u8, 160u8, 62u8, 72u8, 0u8, 52u8, 37u8, 78u8, 54u8, - 177u8, 10u8, 174u8, 46u8, 110u8, 66u8, 173u8, 123u8, 75u8, 104u8, - ], - [ - 162u8, 130u8, 238u8, 121u8, 139u8, 19u8, 47u8, 157u8, 193u8, 30u8, 6u8, - 205u8, 77u8, 142u8, 118u8, 126u8, 86u8, 43u8, 232u8, 112u8, 150u8, 2u8, - 202u8, 20u8, 254u8, 167u8, 171u8, 51u8, 146u8, 172u8, 189u8, 171u8, - ], - [ - 213u8, 54u8, 73u8, 180u8, 146u8, 247u8, 56u8, 187u8, 89u8, 214u8, 130u8, - 80u8, 153u8, 181u8, 149u8, 80u8, 115u8, 239u8, 218u8, 11u8, 249u8, 227u8, - 167u8, 173u8, 32u8, 218u8, 34u8, 225u8, 16u8, 18u8, 46u8, 41u8, - ], - [ - 216u8, 19u8, 178u8, 72u8, 212u8, 156u8, 139u8, 240u8, 139u8, 226u8, - 182u8, 148u8, 113u8, 38u8, 218u8, 103u8, 99u8, 223u8, 49u8, 11u8, 238u8, - 215u8, 190u8, 169u8, 119u8, 86u8, 69u8, 108u8, 87u8, 39u8, 65u8, 154u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for ILightRelayEvents { - const NAME: &'static str = "ILightRelayEvents"; - const COUNT: usize = 6usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::AuthorizationRequirementChanged) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::Genesis) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::ProofLengthChanged) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::Retarget) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::SubmitterAuthorized) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::SubmitterDeauthorized) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 ILightRelayEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::AuthorizationRequirementChanged(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::Genesis(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::ProofLengthChanged(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::Retarget(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::SubmitterAuthorized(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::SubmitterDeauthorized(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::AuthorizationRequirementChanged(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::Genesis(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::ProofLengthChanged(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::Retarget(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::SubmitterAuthorized(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::SubmitterDeauthorized(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`ILightRelay`](self) contract instance. - -See the [wrapper's documentation](`ILightRelayInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> ILightRelayInstance { - ILightRelayInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - ILightRelayInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - ILightRelayInstance::::deploy_builder(provider) - } - /**A [`ILightRelay`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`ILightRelay`](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 ILightRelayInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for ILightRelayInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("ILightRelayInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ILightRelayInstance { - /**Creates a new wrapper around an on-chain [`ILightRelay`](self) contract instance. - -See the [wrapper's documentation](`ILightRelayInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 ILightRelayInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> ILightRelayInstance { - ILightRelayInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ILightRelayInstance { - /// 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( - &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 [`getBlockDifficulty`] function. - pub fn getBlockDifficulty( - &self, - blockNumber: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getBlockDifficultyCall, N> { - self.call_builder( - &getBlockDifficultyCall { - blockNumber, - }, - ) - } - ///Creates a new call builder for the [`getCurrentEpochDifficulty`] function. - pub fn getCurrentEpochDifficulty( - &self, - ) -> alloy_contract::SolCallBuilder<&P, getCurrentEpochDifficultyCall, N> { - self.call_builder(&getCurrentEpochDifficultyCall) - } - ///Creates a new call builder for the [`getPrevEpochDifficulty`] function. - pub fn getPrevEpochDifficulty( - &self, - ) -> alloy_contract::SolCallBuilder<&P, getPrevEpochDifficultyCall, N> { - self.call_builder(&getPrevEpochDifficultyCall) - } - ///Creates a new call builder for the [`getRelayRange`] function. - pub fn getRelayRange( - &self, - ) -> alloy_contract::SolCallBuilder<&P, getRelayRangeCall, N> { - self.call_builder(&getRelayRangeCall) - } - ///Creates a new call builder for the [`retarget`] function. - pub fn retarget( - &self, - headers: alloy::sol_types::private::Bytes, - ) -> alloy_contract::SolCallBuilder<&P, retargetCall, N> { - self.call_builder(&retargetCall { headers }) - } - ///Creates a new call builder for the [`validateChain`] function. - pub fn validateChain( - &self, - headers: alloy::sol_types::private::Bytes, - ) -> alloy_contract::SolCallBuilder<&P, validateChainCall, N> { - self.call_builder(&validateChainCall { headers }) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ILightRelayInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`AuthorizationRequirementChanged`] event. - pub fn AuthorizationRequirementChanged_filter( - &self, - ) -> alloy_contract::Event<&P, AuthorizationRequirementChanged, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`Genesis`] event. - pub fn Genesis_filter(&self) -> alloy_contract::Event<&P, Genesis, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`ProofLengthChanged`] event. - pub fn ProofLengthChanged_filter( - &self, - ) -> alloy_contract::Event<&P, ProofLengthChanged, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`Retarget`] event. - pub fn Retarget_filter(&self) -> alloy_contract::Event<&P, Retarget, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`SubmitterAuthorized`] event. - pub fn SubmitterAuthorized_filter( - &self, - ) -> alloy_contract::Event<&P, SubmitterAuthorized, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`SubmitterDeauthorized`] event. - pub fn SubmitterDeauthorized_filter( - &self, - ) -> alloy_contract::Event<&P, SubmitterDeauthorized, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/i_pell_strategy.rs b/crates/bindings/src/i_pell_strategy.rs deleted file mode 100644 index 206823571..000000000 --- a/crates/bindings/src/i_pell_strategy.rs +++ /dev/null @@ -1,218 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface IPellStrategy {} -``` - -...which was generated by the following JSON ABI: -```json -[] -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod IPellStrategy { - use super::*; - use alloy::sol_types as 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"", - ); - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`IPellStrategy`](self) contract instance. - -See the [wrapper's documentation](`IPellStrategyInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> IPellStrategyInstance { - IPellStrategyInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - IPellStrategyInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - IPellStrategyInstance::::deploy_builder(provider) - } - /**A [`IPellStrategy`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`IPellStrategy`](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 IPellStrategyInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for IPellStrategyInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("IPellStrategyInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPellStrategyInstance { - /**Creates a new wrapper around an on-chain [`IPellStrategy`](self) contract instance. - -See the [wrapper's documentation](`IPellStrategyInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 IPellStrategyInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> IPellStrategyInstance { - IPellStrategyInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPellStrategyInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPellStrategyInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/i_pell_strategy_manager.rs b/crates/bindings/src/i_pell_strategy_manager.rs deleted file mode 100644 index 95cf9a1e6..000000000 --- a/crates/bindings/src/i_pell_strategy_manager.rs +++ /dev/null @@ -1,841 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface IPellStrategyManager { - function depositIntoStrategyWithStaker(address staker, address strategy, address token, uint256 amount) external returns (uint256 shares); - function stakerStrategyShares(address staker, address strategy) external view returns (uint256); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "depositIntoStrategyWithStaker", - "inputs": [ - { - "name": "staker", - "type": "address", - "internalType": "address" - }, - { - "name": "strategy", - "type": "address", - "internalType": "contract IPellStrategy" - }, - { - "name": "token", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "shares", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "stakerStrategyShares", - "inputs": [ - { - "name": "staker", - "type": "address", - "internalType": "address" - }, - { - "name": "strategy", - "type": "address", - "internalType": "contract IPellStrategy" - } - ], - "outputs": [ - { - "name": "", - "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 IPellStrategyManager { - use super::*; - use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `depositIntoStrategyWithStaker(address,address,address,uint256)` and selector `0xe46842b7`. -```solidity -function depositIntoStrategyWithStaker(address staker, address strategy, address token, uint256 amount) external returns (uint256 shares); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct depositIntoStrategyWithStakerCall { - #[allow(missing_docs)] - pub staker: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub strategy: 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, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`depositIntoStrategyWithStaker(address,address,address,uint256)`](depositIntoStrategyWithStakerCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct depositIntoStrategyWithStakerReturn { - #[allow(missing_docs)] - pub shares: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: depositIntoStrategyWithStakerCall) -> Self { - (value.staker, value.strategy, value.token, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for depositIntoStrategyWithStakerCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - staker: tuple.0, - strategy: tuple.1, - token: tuple.2, - amount: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: depositIntoStrategyWithStakerReturn) -> Self { - (value.shares,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for depositIntoStrategyWithStakerReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { shares: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for depositIntoStrategyWithStakerCall { - 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "depositIntoStrategyWithStaker(address,address,address,uint256)"; - const SELECTOR: [u8; 4] = [228u8, 104u8, 66u8, 183u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.staker, - ), - ::tokenize( - &self.strategy, - ), - ::tokenize( - &self.token, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: depositIntoStrategyWithStakerReturn = r.into(); - r.shares - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: depositIntoStrategyWithStakerReturn = r.into(); - r.shares - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `stakerStrategyShares(address,address)` and selector `0x7a7e0d92`. -```solidity -function stakerStrategyShares(address staker, address strategy) external view returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct stakerStrategySharesCall { - #[allow(missing_docs)] - pub staker: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub strategy: alloy::sol_types::private::Address, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`stakerStrategyShares(address,address)`](stakerStrategySharesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct stakerStrategySharesReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: stakerStrategySharesCall) -> Self { - (value.staker, value.strategy) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for stakerStrategySharesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - staker: tuple.0, - strategy: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: stakerStrategySharesReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for stakerStrategySharesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for stakerStrategySharesCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "stakerStrategyShares(address,address)"; - const SELECTOR: [u8; 4] = [122u8, 126u8, 13u8, 146u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.staker, - ), - ::tokenize( - &self.strategy, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: stakerStrategySharesReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: stakerStrategySharesReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`IPellStrategyManager`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum IPellStrategyManagerCalls { - #[allow(missing_docs)] - depositIntoStrategyWithStaker(depositIntoStrategyWithStakerCall), - #[allow(missing_docs)] - stakerStrategyShares(stakerStrategySharesCall), - } - #[automatically_derived] - impl IPellStrategyManagerCalls { - /// 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]] = &[ - [122u8, 126u8, 13u8, 146u8], - [228u8, 104u8, 66u8, 183u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for IPellStrategyManagerCalls { - const NAME: &'static str = "IPellStrategyManagerCalls"; - const MIN_DATA_LENGTH: usize = 64usize; - const COUNT: usize = 2usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::depositIntoStrategyWithStaker(_) => { - ::SELECTOR - } - Self::stakerStrategyShares(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn stakerStrategyShares( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IPellStrategyManagerCalls::stakerStrategyShares) - } - stakerStrategyShares - }, - { - fn depositIntoStrategyWithStaker( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - IPellStrategyManagerCalls::depositIntoStrategyWithStaker, - ) - } - depositIntoStrategyWithStaker - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn stakerStrategyShares( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IPellStrategyManagerCalls::stakerStrategyShares) - } - stakerStrategyShares - }, - { - fn depositIntoStrategyWithStaker( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - IPellStrategyManagerCalls::depositIntoStrategyWithStaker, - ) - } - depositIntoStrategyWithStaker - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::depositIntoStrategyWithStaker(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::stakerStrategyShares(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::depositIntoStrategyWithStaker(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::stakerStrategyShares(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`IPellStrategyManager`](self) contract instance. - -See the [wrapper's documentation](`IPellStrategyManagerInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> IPellStrategyManagerInstance { - IPellStrategyManagerInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - IPellStrategyManagerInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - IPellStrategyManagerInstance::::deploy_builder(provider) - } - /**A [`IPellStrategyManager`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`IPellStrategyManager`](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 IPellStrategyManagerInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for IPellStrategyManagerInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("IPellStrategyManagerInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPellStrategyManagerInstance { - /**Creates a new wrapper around an on-chain [`IPellStrategyManager`](self) contract instance. - -See the [wrapper's documentation](`IPellStrategyManagerInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 IPellStrategyManagerInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> IPellStrategyManagerInstance { - IPellStrategyManagerInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPellStrategyManagerInstance { - /// 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( - &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 [`depositIntoStrategyWithStaker`] function. - pub fn depositIntoStrategyWithStaker( - &self, - staker: alloy::sol_types::private::Address, - strategy: alloy::sol_types::private::Address, - token: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, depositIntoStrategyWithStakerCall, N> { - self.call_builder( - &depositIntoStrategyWithStakerCall { - staker, - strategy, - token, - amount, - }, - ) - } - ///Creates a new call builder for the [`stakerStrategyShares`] function. - pub fn stakerStrategyShares( - &self, - staker: alloy::sol_types::private::Address, - strategy: alloy::sol_types::private::Address, - ) -> alloy_contract::SolCallBuilder<&P, stakerStrategySharesCall, N> { - self.call_builder( - &stakerStrategySharesCall { - staker, - strategy, - }, - ) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPellStrategyManagerInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/i_pool.rs b/crates/bindings/src/i_pool.rs deleted file mode 100644 index 2ce95c4c7..000000000 --- a/crates/bindings/src/i_pool.rs +++ /dev/null @@ -1,740 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface IPool { - function enterMarkets(address[] memory cTokens) external returns (uint256[] memory); - function exitMarket(address cTokenAddress) external returns (uint256); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "enterMarkets", - "inputs": [ - { - "name": "cTokens", - "type": "address[]", - "internalType": "address[]" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "exitMarket", - "inputs": [ - { - "name": "cTokenAddress", - "type": "address", - "internalType": "address" - } - ], - "outputs": [ - { - "name": "", - "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 IPool { - use super::*; - use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `enterMarkets(address[])` and selector `0xc2998238`. -```solidity -function enterMarkets(address[] memory cTokens) external returns (uint256[] memory); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct enterMarketsCall { - #[allow(missing_docs)] - pub cTokens: alloy::sol_types::private::Vec, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`enterMarkets(address[])`](enterMarketsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct enterMarketsReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: enterMarketsCall) -> Self { - (value.cTokens,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for enterMarketsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { cTokens: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - #[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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: enterMarketsReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for enterMarketsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for enterMarketsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::primitives::aliases::U256, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "enterMarkets(address[])"; - const SELECTOR: [u8; 4] = [194u8, 153u8, 130u8, 56u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.cTokens), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: enterMarketsReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: enterMarketsReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `exitMarket(address)` and selector `0xede4edd0`. -```solidity -function exitMarket(address cTokenAddress) external returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct exitMarketCall { - #[allow(missing_docs)] - pub cTokenAddress: alloy::sol_types::private::Address, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`exitMarket(address)`](exitMarketCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct exitMarketReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: exitMarketCall) -> Self { - (value.cTokenAddress,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for exitMarketCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { cTokenAddress: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: exitMarketReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for exitMarketReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for exitMarketCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "exitMarket(address)"; - const SELECTOR: [u8; 4] = [237u8, 228u8, 237u8, 208u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.cTokenAddress, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: exitMarketReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: exitMarketReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`IPool`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum IPoolCalls { - #[allow(missing_docs)] - enterMarkets(enterMarketsCall), - #[allow(missing_docs)] - exitMarket(exitMarketCall), - } - #[automatically_derived] - impl IPoolCalls { - /// 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]] = &[ - [194u8, 153u8, 130u8, 56u8], - [237u8, 228u8, 237u8, 208u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for IPoolCalls { - const NAME: &'static str = "IPoolCalls"; - const MIN_DATA_LENGTH: usize = 32usize; - const COUNT: usize = 2usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::enterMarkets(_) => { - ::SELECTOR - } - Self::exitMarket(_) => { - ::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 { - static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result] = &[ - { - fn enterMarkets(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IPoolCalls::enterMarkets) - } - enterMarkets - }, - { - fn exitMarket(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IPoolCalls::exitMarket) - } - exitMarket - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn enterMarkets(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IPoolCalls::enterMarkets) - } - enterMarkets - }, - { - fn exitMarket(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IPoolCalls::exitMarket) - } - exitMarket - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::enterMarkets(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::exitMarket(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::enterMarkets(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::exitMarket(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`IPool`](self) contract instance. - -See the [wrapper's documentation](`IPoolInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >(address: alloy_sol_types::private::Address, provider: P) -> IPoolInstance { - IPoolInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - IPoolInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - IPoolInstance::::deploy_builder(provider) - } - /**A [`IPool`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`IPool`](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 IPoolInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for IPoolInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("IPoolInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPoolInstance { - /**Creates a new wrapper around an on-chain [`IPool`](self) contract instance. - -See the [wrapper's documentation](`IPoolInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 IPoolInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> IPoolInstance { - IPoolInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPoolInstance { - /// 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( - &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 [`enterMarkets`] function. - pub fn enterMarkets( - &self, - cTokens: alloy::sol_types::private::Vec, - ) -> alloy_contract::SolCallBuilder<&P, enterMarketsCall, N> { - self.call_builder(&enterMarketsCall { cTokens }) - } - ///Creates a new call builder for the [`exitMarket`] function. - pub fn exitMarket( - &self, - cTokenAddress: alloy::sol_types::private::Address, - ) -> alloy_contract::SolCallBuilder<&P, exitMarketCall, N> { - self.call_builder(&exitMarketCall { cTokenAddress }) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPoolInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/i_se_bep20.rs b/crates/bindings/src/i_se_bep20.rs deleted file mode 100644 index b8e5ebe7a..000000000 --- a/crates/bindings/src/i_se_bep20.rs +++ /dev/null @@ -1,1185 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface ISeBep20 { - function balanceOfUnderlying(address owner) external returns (uint256); - function mint(uint256 mintAmount) external returns (uint256); - function mintBehalf(address receiver, uint256 mintAmount) external returns (uint256); - function redeem(uint256 redeemTokens) external returns (uint256); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "balanceOfUnderlying", - "inputs": [ - { - "name": "owner", - "type": "address", - "internalType": "address" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "mint", - "inputs": [ - { - "name": "mintAmount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "mintBehalf", - "inputs": [ - { - "name": "receiver", - "type": "address", - "internalType": "address" - }, - { - "name": "mintAmount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "redeem", - "inputs": [ - { - "name": "redeemTokens", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "", - "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 ISeBep20 { - use super::*; - use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `balanceOfUnderlying(address)` and selector `0x3af9e669`. -```solidity -function balanceOfUnderlying(address owner) external returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct balanceOfUnderlyingCall { - #[allow(missing_docs)] - pub owner: alloy::sol_types::private::Address, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`balanceOfUnderlying(address)`](balanceOfUnderlyingCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct balanceOfUnderlyingReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: balanceOfUnderlyingCall) -> Self { - (value.owner,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for balanceOfUnderlyingCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { owner: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: balanceOfUnderlyingReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for balanceOfUnderlyingReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for balanceOfUnderlyingCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "balanceOfUnderlying(address)"; - const SELECTOR: [u8; 4] = [58u8, 249u8, 230u8, 105u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.owner, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: balanceOfUnderlyingReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: balanceOfUnderlyingReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `mint(uint256)` and selector `0xa0712d68`. -```solidity -function mint(uint256 mintAmount) external returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct mintCall { - #[allow(missing_docs)] - pub mintAmount: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`mint(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: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: mintCall) -> Self { - (value.mintAmount,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for mintCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { mintAmount: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: mintReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "mint(uint256)"; - const SELECTOR: [u8; 4] = [160u8, 113u8, 45u8, 104u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.mintAmount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: mintReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `mintBehalf(address,uint256)` and selector `0x23323e03`. -```solidity -function mintBehalf(address receiver, uint256 mintAmount) external returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct mintBehalfCall { - #[allow(missing_docs)] - pub receiver: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub mintAmount: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`mintBehalf(address,uint256)`](mintBehalfCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct mintBehalfReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: mintBehalfCall) -> Self { - (value.receiver, value.mintAmount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for mintBehalfCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - receiver: tuple.0, - mintAmount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: mintBehalfReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for mintBehalfReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for mintBehalfCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "mintBehalf(address,uint256)"; - const SELECTOR: [u8; 4] = [35u8, 50u8, 62u8, 3u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.receiver, - ), - as alloy_sol_types::SolType>::tokenize(&self.mintAmount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: mintBehalfReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: mintBehalfReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `redeem(uint256)` and selector `0xdb006a75`. -```solidity -function redeem(uint256 redeemTokens) external returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct redeemCall { - #[allow(missing_docs)] - pub redeemTokens: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`redeem(uint256)`](redeemCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct redeemReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: redeemCall) -> Self { - (value.redeemTokens,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for redeemCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { redeemTokens: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: redeemReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for redeemReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for redeemCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "redeem(uint256)"; - const SELECTOR: [u8; 4] = [219u8, 0u8, 106u8, 117u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.redeemTokens), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: redeemReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: redeemReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`ISeBep20`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum ISeBep20Calls { - #[allow(missing_docs)] - balanceOfUnderlying(balanceOfUnderlyingCall), - #[allow(missing_docs)] - mint(mintCall), - #[allow(missing_docs)] - mintBehalf(mintBehalfCall), - #[allow(missing_docs)] - redeem(redeemCall), - } - #[automatically_derived] - impl ISeBep20Calls { - /// 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]] = &[ - [35u8, 50u8, 62u8, 3u8], - [58u8, 249u8, 230u8, 105u8], - [160u8, 113u8, 45u8, 104u8], - [219u8, 0u8, 106u8, 117u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for ISeBep20Calls { - const NAME: &'static str = "ISeBep20Calls"; - const MIN_DATA_LENGTH: usize = 32usize; - const COUNT: usize = 4usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::balanceOfUnderlying(_) => { - ::SELECTOR - } - Self::mint(_) => ::SELECTOR, - Self::mintBehalf(_) => { - ::SELECTOR - } - Self::redeem(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn mintBehalf( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ISeBep20Calls::mintBehalf) - } - mintBehalf - }, - { - fn balanceOfUnderlying( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ISeBep20Calls::balanceOfUnderlying) - } - balanceOfUnderlying - }, - { - fn mint(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ISeBep20Calls::mint) - } - mint - }, - { - fn redeem(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ISeBep20Calls::redeem) - } - redeem - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn mintBehalf( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ISeBep20Calls::mintBehalf) - } - mintBehalf - }, - { - fn balanceOfUnderlying( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ISeBep20Calls::balanceOfUnderlying) - } - balanceOfUnderlying - }, - { - fn mint(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ISeBep20Calls::mint) - } - mint - }, - { - fn redeem(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ISeBep20Calls::redeem) - } - redeem - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::balanceOfUnderlying(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::mint(inner) => { - ::abi_encoded_size(inner) - } - Self::mintBehalf(inner) => { - ::abi_encoded_size(inner) - } - Self::redeem(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::balanceOfUnderlying(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::mint(inner) => { - ::abi_encode_raw(inner, out) - } - Self::mintBehalf(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::redeem(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`ISeBep20`](self) contract instance. - -See the [wrapper's documentation](`ISeBep20Instance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> ISeBep20Instance { - ISeBep20Instance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - ISeBep20Instance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - ISeBep20Instance::::deploy_builder(provider) - } - /**A [`ISeBep20`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`ISeBep20`](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 ISeBep20Instance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for ISeBep20Instance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("ISeBep20Instance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ISeBep20Instance { - /**Creates a new wrapper around an on-chain [`ISeBep20`](self) contract instance. - -See the [wrapper's documentation](`ISeBep20Instance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 ISeBep20Instance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> ISeBep20Instance { - ISeBep20Instance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ISeBep20Instance { - /// 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( - &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 [`balanceOfUnderlying`] function. - pub fn balanceOfUnderlying( - &self, - owner: alloy::sol_types::private::Address, - ) -> alloy_contract::SolCallBuilder<&P, balanceOfUnderlyingCall, N> { - self.call_builder(&balanceOfUnderlyingCall { owner }) - } - ///Creates a new call builder for the [`mint`] function. - pub fn mint( - &self, - mintAmount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> { - self.call_builder(&mintCall { mintAmount }) - } - ///Creates a new call builder for the [`mintBehalf`] function. - pub fn mintBehalf( - &self, - receiver: alloy::sol_types::private::Address, - mintAmount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, mintBehalfCall, N> { - self.call_builder( - &mintBehalfCall { - receiver, - mintAmount, - }, - ) - } - ///Creates a new call builder for the [`redeem`] function. - pub fn redeem( - &self, - redeemTokens: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, redeemCall, N> { - self.call_builder(&redeemCall { redeemTokens }) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ISeBep20Instance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/i_solv_btc_router.rs b/crates/bindings/src/i_solv_btc_router.rs deleted file mode 100644 index 8c233bace..000000000 --- a/crates/bindings/src/i_solv_btc_router.rs +++ /dev/null @@ -1,553 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface ISolvBTCRouter { - function createSubscription(bytes32 poolId, uint256 currencyAmount) external returns (uint256 shareValue); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "createSubscription", - "inputs": [ - { - "name": "poolId", - "type": "bytes32", - "internalType": "bytes32" - }, - { - "name": "currencyAmount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "shareValue", - "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 ISolvBTCRouter { - use super::*; - use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `createSubscription(bytes32,uint256)` and selector `0x6d724ead`. -```solidity -function createSubscription(bytes32 poolId, uint256 currencyAmount) external returns (uint256 shareValue); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct createSubscriptionCall { - #[allow(missing_docs)] - pub poolId: alloy::sol_types::private::FixedBytes<32>, - #[allow(missing_docs)] - pub currencyAmount: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`createSubscription(bytes32,uint256)`](createSubscriptionCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct createSubscriptionReturn { - #[allow(missing_docs)] - pub shareValue: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: createSubscriptionCall) -> Self { - (value.poolId, value.currencyAmount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for createSubscriptionCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - poolId: tuple.0, - currencyAmount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: createSubscriptionReturn) -> Self { - (value.shareValue,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for createSubscriptionReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { shareValue: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for createSubscriptionCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "createSubscription(bytes32,uint256)"; - const SELECTOR: [u8; 4] = [109u8, 114u8, 78u8, 173u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.poolId), - as alloy_sol_types::SolType>::tokenize(&self.currencyAmount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: createSubscriptionReturn = r.into(); - r.shareValue - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: createSubscriptionReturn = r.into(); - r.shareValue - }) - } - } - }; - ///Container for all the [`ISolvBTCRouter`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum ISolvBTCRouterCalls { - #[allow(missing_docs)] - createSubscription(createSubscriptionCall), - } - #[automatically_derived] - impl ISolvBTCRouterCalls { - /// 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]] = &[[109u8, 114u8, 78u8, 173u8]]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for ISolvBTCRouterCalls { - const NAME: &'static str = "ISolvBTCRouterCalls"; - const MIN_DATA_LENGTH: usize = 64usize; - const COUNT: usize = 1usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::createSubscription(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn createSubscription( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ISolvBTCRouterCalls::createSubscription) - } - createSubscription - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn createSubscription( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ISolvBTCRouterCalls::createSubscription) - } - createSubscription - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::createSubscription(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::createSubscription(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`ISolvBTCRouter`](self) contract instance. - -See the [wrapper's documentation](`ISolvBTCRouterInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> ISolvBTCRouterInstance { - ISolvBTCRouterInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - ISolvBTCRouterInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - ISolvBTCRouterInstance::::deploy_builder(provider) - } - /**A [`ISolvBTCRouter`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`ISolvBTCRouter`](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 ISolvBTCRouterInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for ISolvBTCRouterInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("ISolvBTCRouterInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ISolvBTCRouterInstance { - /**Creates a new wrapper around an on-chain [`ISolvBTCRouter`](self) contract instance. - -See the [wrapper's documentation](`ISolvBTCRouterInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 ISolvBTCRouterInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> ISolvBTCRouterInstance { - ISolvBTCRouterInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ISolvBTCRouterInstance { - /// 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( - &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 [`createSubscription`] function. - pub fn createSubscription( - &self, - poolId: alloy::sol_types::private::FixedBytes<32>, - currencyAmount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, createSubscriptionCall, N> { - self.call_builder( - &createSubscriptionCall { - poolId, - currencyAmount, - }, - ) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ISolvBTCRouterInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/i_strategy.rs b/crates/bindings/src/i_strategy.rs deleted file mode 100644 index dbffd2034..000000000 --- a/crates/bindings/src/i_strategy.rs +++ /dev/null @@ -1,782 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface IStrategy { - event TokenOutput(address tokenReceived, uint256 amountOut); - - function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "handleGatewayMessage", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "message", - "type": "bytes", - "internalType": "bytes" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "event", - "name": "TokenOutput", - "inputs": [ - { - "name": "tokenReceived", - "type": "address", - "indexed": false, - "internalType": "address" - }, - { - "name": "amountOut", - "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 IStrategy { - use super::*; - use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. -```solidity -event TokenOutput(address tokenReceived, uint256 amountOut); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct TokenOutput { - #[allow(missing_docs)] - pub tokenReceived: alloy::sol_types::private::Address, - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for TokenOutput { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - tokenReceived: data.0, - amountOut: data.1, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.tokenReceived, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountOut), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 TokenOutput { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&TokenOutput> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. -```solidity -function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub message: alloy::sol_types::private::Bytes, - } - ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ); - #[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, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.message) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - message: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageCall { - 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, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; - const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.message, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`IStrategy`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum IStrategyCalls { - #[allow(missing_docs)] - handleGatewayMessage(handleGatewayMessageCall), - } - #[automatically_derived] - impl IStrategyCalls { - /// 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, 99u8, 76u8, 14u8]]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for IStrategyCalls { - const NAME: &'static str = "IStrategyCalls"; - const MIN_DATA_LENGTH: usize = 160usize; - const COUNT: usize = 1usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::handleGatewayMessage(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::handleGatewayMessage(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::handleGatewayMessage(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`IStrategy`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum IStrategyEvents { - #[allow(missing_docs)] - TokenOutput(TokenOutput), - } - #[automatically_derived] - impl IStrategyEvents { - /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for IStrategyEvents { - const NAME: &'static str = "IStrategyEvents"; - const COUNT: usize = 1usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::TokenOutput) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 IStrategyEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`IStrategy`](self) contract instance. - -See the [wrapper's documentation](`IStrategyInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> IStrategyInstance { - IStrategyInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - IStrategyInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - IStrategyInstance::::deploy_builder(provider) - } - /**A [`IStrategy`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`IStrategy`](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 IStrategyInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for IStrategyInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("IStrategyInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IStrategyInstance { - /**Creates a new wrapper around an on-chain [`IStrategy`](self) contract instance. - -See the [wrapper's documentation](`IStrategyInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 IStrategyInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> IStrategyInstance { - IStrategyInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IStrategyInstance { - /// 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( - &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 [`handleGatewayMessage`] function. - pub fn handleGatewayMessage( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - message: alloy::sol_types::private::Bytes, - ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { - self.call_builder( - &handleGatewayMessageCall { - tokenSent, - amountIn, - recipient, - message, - }, - ) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IStrategyInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`TokenOutput`] event. - pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/i_strategy_with_slippage_args.rs b/crates/bindings/src/i_strategy_with_slippage_args.rs deleted file mode 100644 index 9c26d79c1..000000000 --- a/crates/bindings/src/i_strategy_with_slippage_args.rs +++ /dev/null @@ -1,1275 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface IStrategyWithSlippageArgs { - struct StrategySlippageArgs { - uint256 amountOutMin; - } - - event TokenOutput(address tokenReceived, uint256 amountOut); - - function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; - function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "handleGatewayMessage", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "message", - "type": "bytes", - "internalType": "bytes" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessageWithSlippageArgs", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "args", - "type": "tuple", - "internalType": "struct StrategySlippageArgs", - "components": [ - { - "name": "amountOutMin", - "type": "uint256", - "internalType": "uint256" - } - ] - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "event", - "name": "TokenOutput", - "inputs": [ - { - "name": "tokenReceived", - "type": "address", - "indexed": false, - "internalType": "address" - }, - { - "name": "amountOut", - "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 IStrategyWithSlippageArgs { - use super::*; - use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct StrategySlippageArgs { uint256 amountOutMin; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct StrategySlippageArgs { - #[allow(missing_docs)] - pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: StrategySlippageArgs) -> Self { - (value.amountOutMin,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for StrategySlippageArgs { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { amountOutMin: tuple.0 } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for StrategySlippageArgs { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for StrategySlippageArgs { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for StrategySlippageArgs { - const NAME: &'static str = "StrategySlippageArgs"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "StrategySlippageArgs(uint256 amountOutMin)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) - .0 - .to_vec() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for StrategySlippageArgs { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.amountOutMin, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.amountOutMin, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. -```solidity -event TokenOutput(address tokenReceived, uint256 amountOut); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct TokenOutput { - #[allow(missing_docs)] - pub tokenReceived: alloy::sol_types::private::Address, - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for TokenOutput { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - tokenReceived: data.0, - amountOut: data.1, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.tokenReceived, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountOut), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 TokenOutput { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&TokenOutput> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. -```solidity -function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub message: alloy::sol_types::private::Bytes, - } - ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ); - #[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, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.message) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - message: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageCall { - 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, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; - const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.message, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. -```solidity -function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub args: ::RustType, - } - ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::primitives::aliases::U256, - alloy::sol_types::private::Address, - ::RustType, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.args) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - args: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageWithSlippageArgsReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageWithSlippageArgsReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; - const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.args, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`IStrategyWithSlippageArgs`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum IStrategyWithSlippageArgsCalls { - #[allow(missing_docs)] - handleGatewayMessage(handleGatewayMessageCall), - #[allow(missing_docs)] - handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), - } - #[automatically_derived] - impl IStrategyWithSlippageArgsCalls { - /// 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, 99u8, 76u8, 14u8], - [127u8, 129u8, 79u8, 53u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for IStrategyWithSlippageArgsCalls { - const NAME: &'static str = "IStrategyWithSlippageArgsCalls"; - const MIN_DATA_LENGTH: usize = 128usize; - const COUNT: usize = 2usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::handleGatewayMessage(_) => { - ::SELECTOR - } - Self::handleGatewayMessageWithSlippageArgs(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IStrategyWithSlippageArgsCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - IStrategyWithSlippageArgsCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IStrategyWithSlippageArgsCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - IStrategyWithSlippageArgsCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::handleGatewayMessage(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::handleGatewayMessage(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`IStrategyWithSlippageArgs`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum IStrategyWithSlippageArgsEvents { - #[allow(missing_docs)] - TokenOutput(TokenOutput), - } - #[automatically_derived] - impl IStrategyWithSlippageArgsEvents { - /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for IStrategyWithSlippageArgsEvents { - const NAME: &'static str = "IStrategyWithSlippageArgsEvents"; - const COUNT: usize = 1usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::TokenOutput) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 IStrategyWithSlippageArgsEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`IStrategyWithSlippageArgs`](self) contract instance. - -See the [wrapper's documentation](`IStrategyWithSlippageArgsInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> IStrategyWithSlippageArgsInstance { - IStrategyWithSlippageArgsInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - IStrategyWithSlippageArgsInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - IStrategyWithSlippageArgsInstance::::deploy_builder(provider) - } - /**A [`IStrategyWithSlippageArgs`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`IStrategyWithSlippageArgs`](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 IStrategyWithSlippageArgsInstance< - P, - N = alloy_contract::private::Ethereum, - > { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for IStrategyWithSlippageArgsInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("IStrategyWithSlippageArgsInstance") - .field(&self.address) - .finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IStrategyWithSlippageArgsInstance { - /**Creates a new wrapper around an on-chain [`IStrategyWithSlippageArgs`](self) contract instance. - -See the [wrapper's documentation](`IStrategyWithSlippageArgsInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 IStrategyWithSlippageArgsInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> IStrategyWithSlippageArgsInstance { - IStrategyWithSlippageArgsInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IStrategyWithSlippageArgsInstance { - /// 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( - &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 [`handleGatewayMessage`] function. - pub fn handleGatewayMessage( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - message: alloy::sol_types::private::Bytes, - ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { - self.call_builder( - &handleGatewayMessageCall { - tokenSent, - amountIn, - recipient, - message, - }, - ) - } - ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. - pub fn handleGatewayMessageWithSlippageArgs( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - args: ::RustType, - ) -> alloy_contract::SolCallBuilder< - &P, - handleGatewayMessageWithSlippageArgsCall, - N, - > { - self.call_builder( - &handleGatewayMessageWithSlippageArgsCall { - tokenSent, - amountIn, - recipient, - args, - }, - ) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IStrategyWithSlippageArgsInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`TokenOutput`] event. - pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/i_teller.rs b/crates/bindings/src/i_teller.rs deleted file mode 100644 index 419e9e4e0..000000000 --- a/crates/bindings/src/i_teller.rs +++ /dev/null @@ -1,547 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface ITeller { - function deposit(address depositAsset, uint256 depositAmount, uint256 minimumMint) external payable returns (uint256 shares); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "deposit", - "inputs": [ - { - "name": "depositAsset", - "type": "address", - "internalType": "contract ERC20" - }, - { - "name": "depositAmount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "minimumMint", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "shares", - "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 ITeller { - use super::*; - use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `deposit(address,uint256,uint256)` and selector `0x0efe6a8b`. -```solidity -function deposit(address depositAsset, uint256 depositAmount, uint256 minimumMint) external payable returns (uint256 shares); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct depositCall { - #[allow(missing_docs)] - pub depositAsset: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub depositAmount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub minimumMint: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///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(missing_docs)] - pub shares: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: depositCall) -> Self { - (value.depositAsset, value.depositAmount, value.minimumMint) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for depositCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - depositAsset: tuple.0, - depositAmount: tuple.1, - minimumMint: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: depositReturn) -> Self { - (value.shares,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for depositReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { shares: tuple.0 } - } - } - } - #[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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "deposit(address,uint256,uint256)"; - const SELECTOR: [u8; 4] = [14u8, 254u8, 106u8, 139u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.depositAsset, - ), - as alloy_sol_types::SolType>::tokenize(&self.depositAmount), - as alloy_sol_types::SolType>::tokenize(&self.minimumMint), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: depositReturn = r.into(); - r.shares - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: depositReturn = r.into(); - r.shares - }) - } - } - }; - ///Container for all the [`ITeller`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum ITellerCalls { - #[allow(missing_docs)] - deposit(depositCall), - } - #[automatically_derived] - impl ITellerCalls { - /// 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]]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for ITellerCalls { - const NAME: &'static str = "ITellerCalls"; - const MIN_DATA_LENGTH: usize = 96usize; - const COUNT: usize = 1usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::deposit(_) => ::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 { - static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result] = &[ - { - fn deposit(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ITellerCalls::deposit) - } - deposit - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn deposit(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ITellerCalls::deposit) - } - deposit - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::deposit(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::deposit(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`ITeller`](self) contract instance. - -See the [wrapper's documentation](`ITellerInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >(address: alloy_sol_types::private::Address, provider: P) -> ITellerInstance { - ITellerInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - ITellerInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - ITellerInstance::::deploy_builder(provider) - } - /**A [`ITeller`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`ITeller`](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 ITellerInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for ITellerInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("ITellerInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ITellerInstance { - /**Creates a new wrapper around an on-chain [`ITeller`](self) contract instance. - -See the [wrapper's documentation](`ITellerInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 ITellerInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> ITellerInstance { - ITellerInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ITellerInstance { - /// 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( - &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 [`deposit`] function. - pub fn deposit( - &self, - depositAsset: alloy::sol_types::private::Address, - depositAmount: alloy::sol_types::private::primitives::aliases::U256, - minimumMint: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, depositCall, N> { - self.call_builder( - &depositCall { - depositAsset, - depositAmount, - minimumMint, - }, - ) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ITellerInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/ic_erc20.rs b/crates/bindings/src/ic_erc20.rs deleted file mode 100644 index ef61d26dc..000000000 --- a/crates/bindings/src/ic_erc20.rs +++ /dev/null @@ -1,729 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface ICErc20 { - function balanceOfUnderlying(address owner) external returns (uint256); - function mint(uint256 mintAmount) external returns (uint256); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "balanceOfUnderlying", - "inputs": [ - { - "name": "owner", - "type": "address", - "internalType": "address" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "mint", - "inputs": [ - { - "name": "mintAmount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "", - "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 ICErc20 { - use super::*; - use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `balanceOfUnderlying(address)` and selector `0x3af9e669`. -```solidity -function balanceOfUnderlying(address owner) external returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct balanceOfUnderlyingCall { - #[allow(missing_docs)] - pub owner: alloy::sol_types::private::Address, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`balanceOfUnderlying(address)`](balanceOfUnderlyingCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct balanceOfUnderlyingReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: balanceOfUnderlyingCall) -> Self { - (value.owner,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for balanceOfUnderlyingCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { owner: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: balanceOfUnderlyingReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for balanceOfUnderlyingReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for balanceOfUnderlyingCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "balanceOfUnderlying(address)"; - const SELECTOR: [u8; 4] = [58u8, 249u8, 230u8, 105u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.owner, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: balanceOfUnderlyingReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: balanceOfUnderlyingReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `mint(uint256)` and selector `0xa0712d68`. -```solidity -function mint(uint256 mintAmount) external returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct mintCall { - #[allow(missing_docs)] - pub mintAmount: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`mint(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: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: mintCall) -> Self { - (value.mintAmount,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for mintCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { mintAmount: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: mintReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "mint(uint256)"; - const SELECTOR: [u8; 4] = [160u8, 113u8, 45u8, 104u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.mintAmount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: mintReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`ICErc20`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum ICErc20Calls { - #[allow(missing_docs)] - balanceOfUnderlying(balanceOfUnderlyingCall), - #[allow(missing_docs)] - mint(mintCall), - } - #[automatically_derived] - impl ICErc20Calls { - /// 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]] = &[ - [58u8, 249u8, 230u8, 105u8], - [160u8, 113u8, 45u8, 104u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for ICErc20Calls { - const NAME: &'static str = "ICErc20Calls"; - const MIN_DATA_LENGTH: usize = 32usize; - const COUNT: usize = 2usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::balanceOfUnderlying(_) => { - ::SELECTOR - } - Self::mint(_) => ::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 { - static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result] = &[ - { - fn balanceOfUnderlying( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ICErc20Calls::balanceOfUnderlying) - } - balanceOfUnderlying - }, - { - fn mint(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ICErc20Calls::mint) - } - mint - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn balanceOfUnderlying( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ICErc20Calls::balanceOfUnderlying) - } - balanceOfUnderlying - }, - { - fn mint(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ICErc20Calls::mint) - } - mint - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::balanceOfUnderlying(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::mint(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::balanceOfUnderlying(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::mint(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`ICErc20`](self) contract instance. - -See the [wrapper's documentation](`ICErc20Instance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >(address: alloy_sol_types::private::Address, provider: P) -> ICErc20Instance { - ICErc20Instance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - ICErc20Instance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - ICErc20Instance::::deploy_builder(provider) - } - /**A [`ICErc20`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`ICErc20`](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 ICErc20Instance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for ICErc20Instance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("ICErc20Instance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ICErc20Instance { - /**Creates a new wrapper around an on-chain [`ICErc20`](self) contract instance. - -See the [wrapper's documentation](`ICErc20Instance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 ICErc20Instance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> ICErc20Instance { - ICErc20Instance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ICErc20Instance { - /// 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( - &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 [`balanceOfUnderlying`] function. - pub fn balanceOfUnderlying( - &self, - owner: alloy::sol_types::private::Address, - ) -> alloy_contract::SolCallBuilder<&P, balanceOfUnderlyingCall, N> { - self.call_builder(&balanceOfUnderlyingCall { owner }) - } - ///Creates a new call builder for the [`mint`] function. - pub fn mint( - &self, - mintAmount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> { - self.call_builder(&mintCall { mintAmount }) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ICErc20Instance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/ierc20.rs b/crates/bindings/src/ierc20.rs deleted file mode 100644 index d3ac2fdb4..000000000 --- a/crates/bindings/src/ierc20.rs +++ /dev/null @@ -1,2049 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface IERC20 { - event Approval(address indexed owner, address indexed spender, uint256 value); - event Transfer(address indexed from, address indexed to, uint256 value); - - 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 totalSupply() 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": "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": "totalSupply", - "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" - }, - { - "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 IERC20 { - use super::*; - use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for Approval { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - 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, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - owner: topics.1, - spender: topics.2, - value: data.0, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.value), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = ::encode_topic( - &self.owner, - ); - out[2usize] = ::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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for Transfer { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - 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, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - from: topics.1, - to: topics.2, - value: data.0, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.value), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = ::encode_topic( - &self.from, - ); - out[2usize] = ::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(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: allowanceCall) -> Self { - (value.owner, value.spender) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for allowanceCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - owner: tuple.0, - spender: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: allowanceReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "allowance(address,address)"; - const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.owner, - ), - ::tokenize( - &self.spender, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: allowanceReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: approveCall) -> Self { - (value.spender, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for approveCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - spender: tuple.0, - amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: approveReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "approve(address,uint256)"; - const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.spender, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: approveReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: balanceOfCall) -> Self { - (value.account,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for balanceOfCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { account: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: balanceOfReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "balanceOf(address)"; - const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.account, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: balanceOfReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: totalSupplyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for totalSupplyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: totalSupplyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for totalSupplyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for totalSupplyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "totalSupply()"; - const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: totalSupplyReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferCall) -> Self { - (value.to, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for transferCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - to: tuple.0, - amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "transfer(address,uint256)"; - const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.to, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: transferReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferFromCall) -> Self { - (value.from, value.to, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for transferFromCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - from: tuple.0, - to: tuple.1, - amount: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferFromReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "transferFrom(address,address,uint256)"; - const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.from, - ), - ::tokenize( - &self.to, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: transferFromReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`IERC20`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum IERC20Calls { - #[allow(missing_docs)] - allowance(allowanceCall), - #[allow(missing_docs)] - approve(approveCall), - #[allow(missing_docs)] - balanceOf(balanceOfCall), - #[allow(missing_docs)] - totalSupply(totalSupplyCall), - #[allow(missing_docs)] - transfer(transferCall), - #[allow(missing_docs)] - transferFrom(transferFromCall), - } - #[automatically_derived] - impl IERC20Calls { - /// 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], - [112u8, 160u8, 130u8, 49u8], - [169u8, 5u8, 156u8, 187u8], - [221u8, 98u8, 237u8, 62u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for IERC20Calls { - const NAME: &'static str = "IERC20Calls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 6usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::allowance(_) => { - ::SELECTOR - } - Self::approve(_) => ::SELECTOR, - Self::balanceOf(_) => { - ::SELECTOR - } - Self::totalSupply(_) => { - ::SELECTOR - } - Self::transfer(_) => ::SELECTOR, - Self::transferFrom(_) => { - ::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 { - static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result] = &[ - { - fn approve(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IERC20Calls::approve) - } - approve - }, - { - fn totalSupply(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IERC20Calls::totalSupply) - } - totalSupply - }, - { - fn transferFrom( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IERC20Calls::transferFrom) - } - transferFrom - }, - { - fn balanceOf(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IERC20Calls::balanceOf) - } - balanceOf - }, - { - fn transfer(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IERC20Calls::transfer) - } - transfer - }, - { - fn allowance(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IERC20Calls::allowance) - } - allowance - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn approve(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IERC20Calls::approve) - } - approve - }, - { - fn totalSupply(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IERC20Calls::totalSupply) - } - totalSupply - }, - { - fn transferFrom( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IERC20Calls::transferFrom) - } - transferFrom - }, - { - fn balanceOf(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IERC20Calls::balanceOf) - } - balanceOf - }, - { - fn transfer(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IERC20Calls::transfer) - } - transfer - }, - { - fn allowance(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IERC20Calls::allowance) - } - allowance - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::allowance(inner) => { - ::abi_encoded_size(inner) - } - Self::approve(inner) => { - ::abi_encoded_size(inner) - } - Self::balanceOf(inner) => { - ::abi_encoded_size(inner) - } - Self::totalSupply(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::transfer(inner) => { - ::abi_encoded_size(inner) - } - Self::transferFrom(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::allowance(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::approve(inner) => { - ::abi_encode_raw(inner, out) - } - Self::balanceOf(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::totalSupply(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::transfer(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::transferFrom(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`IERC20`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum IERC20Events { - #[allow(missing_docs)] - Approval(Approval), - #[allow(missing_docs)] - Transfer(Transfer), - } - #[automatically_derived] - impl IERC20Events { - /// 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, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for IERC20Events { - const NAME: &'static str = "IERC20Events"; - const COUNT: usize = 2usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::Approval) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::Transfer) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 IERC20Events { - 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 as alloy_contract; - /**Creates a new wrapper around an on-chain [`IERC20`](self) contract instance. - -See the [wrapper's documentation](`IERC20Instance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >(address: alloy_sol_types::private::Address, provider: P) -> IERC20Instance { - IERC20Instance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - IERC20Instance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - IERC20Instance::::deploy_builder(provider) - } - /**A [`IERC20`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`IERC20`](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 IERC20Instance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for IERC20Instance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("IERC20Instance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IERC20Instance { - /**Creates a new wrapper around an on-chain [`IERC20`](self) contract instance. - -See the [wrapper's documentation](`IERC20Instance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 IERC20Instance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> IERC20Instance { - IERC20Instance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IERC20Instance { - /// 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( - &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 [`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, - 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. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IERC20Instance { - /// 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( - &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::() - } - ///Creates a new event filter for the [`Transfer`] event. - pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/ierc20_metadata.rs b/crates/bindings/src/ierc20_metadata.rs deleted file mode 100644 index 10d467cdb..000000000 --- a/crates/bindings/src/ierc20_metadata.rs +++ /dev/null @@ -1,2650 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface IERC20Metadata { - event Approval(address indexed owner, address indexed spender, uint256 value); - event Transfer(address indexed from, address indexed to, uint256 value); - - 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 name() external view returns (string memory); - function symbol() external view returns (string memory); - function totalSupply() 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": "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": "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": "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" - }, - { - "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 IERC20Metadata { - use super::*; - use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for Approval { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - 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, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - owner: topics.1, - spender: topics.2, - value: data.0, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.value), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = ::encode_topic( - &self.owner, - ); - out[2usize] = ::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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for Transfer { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - 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, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - from: topics.1, - to: topics.2, - value: data.0, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.value), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = ::encode_topic( - &self.from, - ); - out[2usize] = ::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(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: allowanceCall) -> Self { - (value.owner, value.spender) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for allowanceCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - owner: tuple.0, - spender: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: allowanceReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "allowance(address,address)"; - const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.owner, - ), - ::tokenize( - &self.spender, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: allowanceReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: approveCall) -> Self { - (value.spender, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for approveCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - spender: tuple.0, - amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: approveReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "approve(address,uint256)"; - const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.spender, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: approveReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: balanceOfCall) -> Self { - (value.account,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for balanceOfCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { account: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: balanceOfReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "balanceOf(address)"; - const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.account, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: balanceOfReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: decimalsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for decimalsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: decimalsReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for decimalsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for decimalsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = u8; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "decimals()"; - const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: decimalsReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: nameCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for nameCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: nameReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for nameReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for nameCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::String; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "name()"; - const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: nameReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: symbolCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for symbolCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: symbolReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for symbolReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for symbolCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::String; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "symbol()"; - const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: symbolReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: totalSupplyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for totalSupplyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: totalSupplyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for totalSupplyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for totalSupplyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "totalSupply()"; - const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: totalSupplyReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferCall) -> Self { - (value.to, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for transferCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - to: tuple.0, - amount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "transfer(address,uint256)"; - const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.to, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: transferReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferFromCall) -> Self { - (value.from, value.to, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for transferFromCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - from: tuple.0, - to: tuple.1, - amount: tuple.2, - } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: transferFromReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> 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 Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "transferFrom(address,address,uint256)"; - const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.from, - ), - ::tokenize( - &self.to, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: transferFromReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`IERC20Metadata`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum IERC20MetadataCalls { - #[allow(missing_docs)] - allowance(allowanceCall), - #[allow(missing_docs)] - approve(approveCall), - #[allow(missing_docs)] - balanceOf(balanceOfCall), - #[allow(missing_docs)] - decimals(decimalsCall), - #[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), - } - #[automatically_derived] - impl IERC20MetadataCalls { - /// 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], - [112u8, 160u8, 130u8, 49u8], - [149u8, 216u8, 155u8, 65u8], - [169u8, 5u8, 156u8, 187u8], - [221u8, 98u8, 237u8, 62u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for IERC20MetadataCalls { - const NAME: &'static str = "IERC20MetadataCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 9usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::allowance(_) => { - ::SELECTOR - } - Self::approve(_) => ::SELECTOR, - Self::balanceOf(_) => { - ::SELECTOR - } - Self::decimals(_) => ::SELECTOR, - Self::name(_) => ::SELECTOR, - Self::symbol(_) => ::SELECTOR, - Self::totalSupply(_) => { - ::SELECTOR - } - Self::transfer(_) => ::SELECTOR, - Self::transferFrom(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn name( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IERC20MetadataCalls::name) - } - name - }, - { - fn approve( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IERC20MetadataCalls::approve) - } - approve - }, - { - fn totalSupply( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IERC20MetadataCalls::totalSupply) - } - totalSupply - }, - { - fn transferFrom( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IERC20MetadataCalls::transferFrom) - } - transferFrom - }, - { - fn decimals( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IERC20MetadataCalls::decimals) - } - decimals - }, - { - fn balanceOf( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IERC20MetadataCalls::balanceOf) - } - balanceOf - }, - { - fn symbol( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IERC20MetadataCalls::symbol) - } - symbol - }, - { - fn transfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IERC20MetadataCalls::transfer) - } - transfer - }, - { - fn allowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IERC20MetadataCalls::allowance) - } - allowance - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn name( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IERC20MetadataCalls::name) - } - name - }, - { - fn approve( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IERC20MetadataCalls::approve) - } - approve - }, - { - fn totalSupply( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IERC20MetadataCalls::totalSupply) - } - totalSupply - }, - { - fn transferFrom( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IERC20MetadataCalls::transferFrom) - } - transferFrom - }, - { - fn decimals( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IERC20MetadataCalls::decimals) - } - decimals - }, - { - fn balanceOf( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IERC20MetadataCalls::balanceOf) - } - balanceOf - }, - { - fn symbol( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IERC20MetadataCalls::symbol) - } - symbol - }, - { - fn transfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IERC20MetadataCalls::transfer) - } - transfer - }, - { - fn allowance( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IERC20MetadataCalls::allowance) - } - allowance - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::allowance(inner) => { - ::abi_encoded_size(inner) - } - Self::approve(inner) => { - ::abi_encoded_size(inner) - } - Self::balanceOf(inner) => { - ::abi_encoded_size(inner) - } - Self::decimals(inner) => { - ::abi_encoded_size(inner) - } - Self::name(inner) => { - ::abi_encoded_size(inner) - } - Self::symbol(inner) => { - ::abi_encoded_size(inner) - } - Self::totalSupply(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::transfer(inner) => { - ::abi_encoded_size(inner) - } - Self::transferFrom(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::allowance(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::approve(inner) => { - ::abi_encode_raw(inner, out) - } - Self::balanceOf(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::decimals(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::name(inner) => { - ::abi_encode_raw(inner, out) - } - Self::symbol(inner) => { - ::abi_encode_raw(inner, out) - } - Self::totalSupply(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::transfer(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::transferFrom(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`IERC20Metadata`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum IERC20MetadataEvents { - #[allow(missing_docs)] - Approval(Approval), - #[allow(missing_docs)] - Transfer(Transfer), - } - #[automatically_derived] - impl IERC20MetadataEvents { - /// 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, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for IERC20MetadataEvents { - const NAME: &'static str = "IERC20MetadataEvents"; - const COUNT: usize = 2usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::Approval) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::Transfer) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 IERC20MetadataEvents { - 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 as alloy_contract; - /**Creates a new wrapper around an on-chain [`IERC20Metadata`](self) contract instance. - -See the [wrapper's documentation](`IERC20MetadataInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> IERC20MetadataInstance { - IERC20MetadataInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - IERC20MetadataInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - IERC20MetadataInstance::::deploy_builder(provider) - } - /**A [`IERC20Metadata`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`IERC20Metadata`](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 IERC20MetadataInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for IERC20MetadataInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("IERC20MetadataInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IERC20MetadataInstance { - /**Creates a new wrapper around an on-chain [`IERC20Metadata`](self) contract instance. - -See the [wrapper's documentation](`IERC20MetadataInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 IERC20MetadataInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> IERC20MetadataInstance { - IERC20MetadataInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IERC20MetadataInstance { - /// 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( - &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 [`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, - 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. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IERC20MetadataInstance { - /// 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( - &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::() - } - ///Creates a new event filter for the [`Transfer`] event. - pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/ierc2771_recipient.rs b/crates/bindings/src/ierc2771_recipient.rs deleted file mode 100644 index 29732235a..000000000 --- a/crates/bindings/src/ierc2771_recipient.rs +++ /dev/null @@ -1,527 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface IERC2771Recipient { - function isTrustedForwarder(address forwarder) external view returns (bool); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "isTrustedForwarder", - "inputs": [ - { - "name": "forwarder", - "type": "address", - "internalType": "address" - } - ], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - } -] -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod IERC2771Recipient { - use super::*; - use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `isTrustedForwarder(address)` and selector `0x572b6c05`. -```solidity -function isTrustedForwarder(address forwarder) external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct isTrustedForwarderCall { - #[allow(missing_docs)] - pub forwarder: alloy::sol_types::private::Address, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`isTrustedForwarder(address)`](isTrustedForwarderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct isTrustedForwarderReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: isTrustedForwarderCall) -> Self { - (value.forwarder,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for isTrustedForwarderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { forwarder: tuple.0 } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: isTrustedForwarderReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for isTrustedForwarderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for isTrustedForwarderCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "isTrustedForwarder(address)"; - const SELECTOR: [u8; 4] = [87u8, 43u8, 108u8, 5u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.forwarder, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: isTrustedForwarderReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: isTrustedForwarderReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`IERC2771Recipient`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum IERC2771RecipientCalls { - #[allow(missing_docs)] - isTrustedForwarder(isTrustedForwarderCall), - } - #[automatically_derived] - impl IERC2771RecipientCalls { - /// 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]] = &[[87u8, 43u8, 108u8, 5u8]]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for IERC2771RecipientCalls { - const NAME: &'static str = "IERC2771RecipientCalls"; - const MIN_DATA_LENGTH: usize = 32usize; - const COUNT: usize = 1usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::isTrustedForwarder(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn isTrustedForwarder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IERC2771RecipientCalls::isTrustedForwarder) - } - isTrustedForwarder - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn isTrustedForwarder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IERC2771RecipientCalls::isTrustedForwarder) - } - isTrustedForwarder - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::isTrustedForwarder(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::isTrustedForwarder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`IERC2771Recipient`](self) contract instance. - -See the [wrapper's documentation](`IERC2771RecipientInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> IERC2771RecipientInstance { - IERC2771RecipientInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - IERC2771RecipientInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - IERC2771RecipientInstance::::deploy_builder(provider) - } - /**A [`IERC2771Recipient`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`IERC2771Recipient`](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 IERC2771RecipientInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for IERC2771RecipientInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("IERC2771RecipientInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IERC2771RecipientInstance { - /**Creates a new wrapper around an on-chain [`IERC2771Recipient`](self) contract instance. - -See the [wrapper's documentation](`IERC2771RecipientInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 IERC2771RecipientInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> IERC2771RecipientInstance { - IERC2771RecipientInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IERC2771RecipientInstance { - /// 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( - &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 [`isTrustedForwarder`] function. - pub fn isTrustedForwarder( - &self, - forwarder: alloy::sol_types::private::Address, - ) -> alloy_contract::SolCallBuilder<&P, isTrustedForwarderCall, N> { - self.call_builder( - &isTrustedForwarderCall { - forwarder, - }, - ) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IERC2771RecipientInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/ionic_strategy.rs b/crates/bindings/src/ionic_strategy.rs deleted file mode 100644 index 3e8c05f85..000000000 --- a/crates/bindings/src/ionic_strategy.rs +++ /dev/null @@ -1,1767 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface IonicStrategy { - struct StrategySlippageArgs { - uint256 amountOutMin; - } - - event TokenOutput(address tokenReceived, uint256 amountOut); - - constructor(address _ioErc20, address _pool); - - function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; - function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; - function ioErc20() external view returns (address); - function pool() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "_ioErc20", - "type": "address", - "internalType": "contract IIonicToken" - }, - { - "name": "_pool", - "type": "address", - "internalType": "contract IPool" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessage", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "message", - "type": "bytes", - "internalType": "bytes" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessageWithSlippageArgs", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "args", - "type": "tuple", - "internalType": "struct StrategySlippageArgs", - "components": [ - { - "name": "amountOutMin", - "type": "uint256", - "internalType": "uint256" - } - ] - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "ioErc20", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IIonicToken" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "pool", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IPool" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "TokenOutput", - "inputs": [ - { - "name": "tokenReceived", - "type": "address", - "indexed": false, - "internalType": "address" - }, - { - "name": "amountOut", - "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 IonicStrategy { - use super::*; - use alloy::sol_types as 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\x11.8\x03\x80a\x11.\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x10Qa\0\xDD_9_\x81\x81`S\x01Ra\x02\xD1\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xBF\x01R\x81\x81a\x02S\x01R\x81\x81a\x03\xE8\x01Ra\x05\xD4\x01Ra\x10Q_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x16\xF0\x11[\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xF6s\xF0\xD9\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\x0C\xB1V[a\0\xEDV[\0[a\0\xB1a\0\xC16`\x04a\rsV[a\x01\x17V[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[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\r\xF7V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x07LV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x08\x10V[`@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\x83\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\x91_\x91\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0E\x1BV[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R\x91\x92P_\x91\x90` \x80\x83\x01\x90\x806\x837\x01\x90PP\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\x81_\x81Q\x81\x10a\x02\x84Wa\x02\x84a\x0E2V[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`@Q\x7F\xC2\x99\x828\0\0\0\0\0\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\x7F\0\0\0\0\0\0\0\0\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\xC2\x99\x828\x90a\x03\x06\x90\x85\x90`\x04\x01a\x0E_V[_`@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03!W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x03H\x91\x90\x81\x01\x90a\x0E\xB7V[\x90P\x80_\x81Q\x81\x10a\x03\\Wa\x03\\a\x0E2V[` \x02` \x01\x01Q_\x14a\x03\xB7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FCouldn't enter in Market\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@Q\x7F\xA0q-h\0\0\0\0\0\0\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\x88\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\xA0q-h\x90`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04g\x91\x90a\x0E\x1BV[\x90P\x80\x15a\x04\xDCW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FCould not mint token in Ionic ma`D\x82\x01R\x7Frket\0\0\0\0\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\x03\xAEV[`@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\x87\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05j\x91\x90a\x0E\x1BV[\x90Pa\x05\x8Ds\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x89\x83a\t\x0BV[`@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\x89\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\x1BW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06?\x91\x90a\x0E\x1BV[\x90P\x85\x81\x11a\x06\x90W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01a\x03\xAEV[_a\x06\x9B\x87\x83a\x0F\x85V[\x89Q\x90\x91P\x81\x10\x15a\x06\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xAEV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8A\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x08\n\x90\x85\x90\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\x90`\x84\x01[`@\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\tfV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x84W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\xA8\x91\x90a\x0E\x1BV[a\x08\xB2\x91\x90a\x0F\x9EV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x08\n\x90\x85\x90\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\x90`d\x01a\x07\xA6V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\ta\x90\x84\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\x90`d\x01a\x07\xA6V[PPPV[_a\t\xC7\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\nW\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\taW\x80\x80` \x01\x90Q\x81\x01\x90a\t\xE5\x91\x90a\x0F\xB1V[a\taW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xAEV[``a\ne\x84\x84_\x85a\noV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\n\xE7W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xAEV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x0BKW`@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\x03\xAEV[__\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\x0Bs\x91\x90a\x0F\xD0V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x0B\xADW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x0B\xB2V[``\x91P[P\x91P\x91Pa\x0B\xC2\x82\x82\x86a\x0B\xCDV[\x97\x96PPPPPPPV[``\x83\x15a\x0B\xDCWP\x81a\nhV[\x82Q\x15a\x0B\xECW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xAE\x91\x90a\x0F\xE6V[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\x0C'W__\xFD[PV[\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\x0CzWa\x0Cza\x0C*V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0C\xA9Wa\x0C\xA9a\x0C*V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0C\xC4W__\xFD[\x845a\x0C\xCF\x81a\x0C\x06V[\x93P` \x85\x015\x92P`@\x85\x015a\x0C\xE6\x81a\x0C\x06V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\x01W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\r\x11W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r+Wa\r+a\x0C*V[a\r>` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0C\x80V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\rRW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\r\x87W__\xFD[\x855a\r\x92\x81a\x0C\x06V[\x94P` \x86\x015\x93P`@\x86\x015a\r\xA9\x81a\x0C\x06V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\r\xDAW__\xFD[Pa\r\xE3a\x0CWV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0E\x08W__\xFD[Pa\x0E\x11a\x0CWV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0E+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[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x0E\xACW\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\x0ExV[P\x90\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x0E\xC7W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0E\xDDW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x0E\xEDW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0F\x07Wa\x0F\x07a\x0C*V[\x80`\x05\x1Ba\x0F\x17` \x82\x01a\x0C\x80V[\x91\x82R` \x81\x84\x01\x81\x01\x92\x90\x81\x01\x90\x87\x84\x11\x15a\x0F2W__\xFD[` \x85\x01\x94P[\x83\x85\x10\x15a\x0B\xC2W\x84Q\x80\x83R` \x95\x86\x01\x95\x90\x93P\x90\x91\x01\x90a\x0F9V[\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\x0F\x98Wa\x0F\x98a\x0FXV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0F\x98Wa\x0F\x98a\x0FXV[_` \x82\x84\x03\x12\x15a\x0F\xC1W__\xFD[\x81Q\x80\x15\x15\x81\x14a\nhW__\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\xFE\xA2dipfsX\"\x12 \xA63\xC5\xE5\xEB@\xCE\xD5\xA8\xAC\xC4\xC9\xF1HKy%\x82\xCD\xE3]\xB9\xCEE\xC8l\xF1O\x15\xEA\xD7\xF0dsolcC\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\x16\xF0\x11[\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xF6s\xF0\xD9\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\x0C\xB1V[a\0\xEDV[\0[a\0\xB1a\0\xC16`\x04a\rsV[a\x01\x17V[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[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\r\xF7V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x07LV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x08\x10V[`@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\x83\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\x91_\x91\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0E\x1BV[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R\x91\x92P_\x91\x90` \x80\x83\x01\x90\x806\x837\x01\x90PP\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\x81_\x81Q\x81\x10a\x02\x84Wa\x02\x84a\x0E2V[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`@Q\x7F\xC2\x99\x828\0\0\0\0\0\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\x7F\0\0\0\0\0\0\0\0\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\xC2\x99\x828\x90a\x03\x06\x90\x85\x90`\x04\x01a\x0E_V[_`@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03!W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x03H\x91\x90\x81\x01\x90a\x0E\xB7V[\x90P\x80_\x81Q\x81\x10a\x03\\Wa\x03\\a\x0E2V[` \x02` \x01\x01Q_\x14a\x03\xB7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FCouldn't enter in Market\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@Q\x7F\xA0q-h\0\0\0\0\0\0\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\x88\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\xA0q-h\x90`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04g\x91\x90a\x0E\x1BV[\x90P\x80\x15a\x04\xDCW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FCould not mint token in Ionic ma`D\x82\x01R\x7Frket\0\0\0\0\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\x03\xAEV[`@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\x87\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05j\x91\x90a\x0E\x1BV[\x90Pa\x05\x8Ds\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x89\x83a\t\x0BV[`@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\x89\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\x1BW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06?\x91\x90a\x0E\x1BV[\x90P\x85\x81\x11a\x06\x90W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01a\x03\xAEV[_a\x06\x9B\x87\x83a\x0F\x85V[\x89Q\x90\x91P\x81\x10\x15a\x06\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xAEV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8A\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x08\n\x90\x85\x90\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\x90`\x84\x01[`@\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\tfV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x84W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\xA8\x91\x90a\x0E\x1BV[a\x08\xB2\x91\x90a\x0F\x9EV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x08\n\x90\x85\x90\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\x90`d\x01a\x07\xA6V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\ta\x90\x84\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\x90`d\x01a\x07\xA6V[PPPV[_a\t\xC7\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\nW\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\taW\x80\x80` \x01\x90Q\x81\x01\x90a\t\xE5\x91\x90a\x0F\xB1V[a\taW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xAEV[``a\ne\x84\x84_\x85a\noV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\n\xE7W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xAEV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x0BKW`@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\x03\xAEV[__\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\x0Bs\x91\x90a\x0F\xD0V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x0B\xADW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x0B\xB2V[``\x91P[P\x91P\x91Pa\x0B\xC2\x82\x82\x86a\x0B\xCDV[\x97\x96PPPPPPPV[``\x83\x15a\x0B\xDCWP\x81a\nhV[\x82Q\x15a\x0B\xECW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xAE\x91\x90a\x0F\xE6V[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\x0C'W__\xFD[PV[\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\x0CzWa\x0Cza\x0C*V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0C\xA9Wa\x0C\xA9a\x0C*V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0C\xC4W__\xFD[\x845a\x0C\xCF\x81a\x0C\x06V[\x93P` \x85\x015\x92P`@\x85\x015a\x0C\xE6\x81a\x0C\x06V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\x01W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\r\x11W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r+Wa\r+a\x0C*V[a\r>` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0C\x80V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\rRW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\r\x87W__\xFD[\x855a\r\x92\x81a\x0C\x06V[\x94P` \x86\x015\x93P`@\x86\x015a\r\xA9\x81a\x0C\x06V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\r\xDAW__\xFD[Pa\r\xE3a\x0CWV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0E\x08W__\xFD[Pa\x0E\x11a\x0CWV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0E+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[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x0E\xACW\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\x0ExV[P\x90\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x0E\xC7W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0E\xDDW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x0E\xEDW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0F\x07Wa\x0F\x07a\x0C*V[\x80`\x05\x1Ba\x0F\x17` \x82\x01a\x0C\x80V[\x91\x82R` \x81\x84\x01\x81\x01\x92\x90\x81\x01\x90\x87\x84\x11\x15a\x0F2W__\xFD[` \x85\x01\x94P[\x83\x85\x10\x15a\x0B\xC2W\x84Q\x80\x83R` \x95\x86\x01\x95\x90\x93P\x90\x91\x01\x90a\x0F9V[\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\x0F\x98Wa\x0F\x98a\x0FXV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0F\x98Wa\x0F\x98a\x0FXV[_` \x82\x84\x03\x12\x15a\x0F\xC1W__\xFD[\x81Q\x80\x15\x15\x81\x14a\nhW__\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\xFE\xA2dipfsX\"\x12 \xA63\xC5\xE5\xEB@\xCE\xD5\xA8\xAC\xC4\xC9\xF1HKy%\x82\xCD\xE3]\xB9\xCEE\xC8l\xF1O\x15\xEA\xD7\xF0dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct StrategySlippageArgs { uint256 amountOutMin; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct StrategySlippageArgs { - #[allow(missing_docs)] - pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: StrategySlippageArgs) -> Self { - (value.amountOutMin,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for StrategySlippageArgs { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { amountOutMin: tuple.0 } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for StrategySlippageArgs { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for StrategySlippageArgs { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for StrategySlippageArgs { - const NAME: &'static str = "StrategySlippageArgs"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "StrategySlippageArgs(uint256 amountOutMin)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) - .0 - .to_vec() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for StrategySlippageArgs { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.amountOutMin, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.amountOutMin, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. -```solidity -event TokenOutput(address tokenReceived, uint256 amountOut); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct TokenOutput { - #[allow(missing_docs)] - pub tokenReceived: alloy::sol_types::private::Address, - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for TokenOutput { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - tokenReceived: data.0, - amountOut: data.1, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.tokenReceived, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountOut), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 TokenOutput { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&TokenOutput> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - /**Constructor`. -```solidity -constructor(address _ioErc20, address _pool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct constructorCall { - #[allow(missing_docs)] - pub _ioErc20: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub _pool: alloy::sol_types::private::Address, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value._ioErc20, value._pool) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - _ioErc20: tuple.0, - _pool: 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> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._ioErc20, - ), - ::tokenize( - &self._pool, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. -```solidity -function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub message: alloy::sol_types::private::Bytes, - } - ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ); - #[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, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.message) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - message: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageCall { - 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, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; - const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.message, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. -```solidity -function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub args: ::RustType, - } - ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::primitives::aliases::U256, - alloy::sol_types::private::Address, - ::RustType, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.args) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - args: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageWithSlippageArgsReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageWithSlippageArgsReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; - const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.args, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `ioErc20()` and selector `0xf673f0d9`. -```solidity -function ioErc20() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct ioErc20Call; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`ioErc20()`](ioErc20Call) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct ioErc20Return { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: ioErc20Call) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for ioErc20Call { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: ioErc20Return) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for ioErc20Return { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for ioErc20Call { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "ioErc20()"; - const SELECTOR: [u8; 4] = [246u8, 115u8, 240u8, 217u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: ioErc20Return = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: ioErc20Return = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `pool()` and selector `0x16f0115b`. -```solidity -function pool() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct poolCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`pool()`](poolCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct poolReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: poolCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for poolCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: poolReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for poolReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for poolCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "pool()"; - const SELECTOR: [u8; 4] = [22u8, 240u8, 17u8, 91u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: poolReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: poolReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`IonicStrategy`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum IonicStrategyCalls { - #[allow(missing_docs)] - handleGatewayMessage(handleGatewayMessageCall), - #[allow(missing_docs)] - handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), - #[allow(missing_docs)] - ioErc20(ioErc20Call), - #[allow(missing_docs)] - pool(poolCall), - } - #[automatically_derived] - impl IonicStrategyCalls { - /// 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, 240u8, 17u8, 91u8], - [80u8, 99u8, 76u8, 14u8], - [127u8, 129u8, 79u8, 53u8], - [246u8, 115u8, 240u8, 217u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for IonicStrategyCalls { - const NAME: &'static str = "IonicStrategyCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 4usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::handleGatewayMessage(_) => { - ::SELECTOR - } - Self::handleGatewayMessageWithSlippageArgs(_) => { - ::SELECTOR - } - Self::ioErc20(_) => ::SELECTOR, - Self::pool(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn pool(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IonicStrategyCalls::pool) - } - pool - }, - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IonicStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - IonicStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - { - fn ioErc20( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IonicStrategyCalls::ioErc20) - } - ioErc20 - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn pool(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IonicStrategyCalls::pool) - } - pool - }, - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IonicStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - IonicStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - { - fn ioErc20( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IonicStrategyCalls::ioErc20) - } - ioErc20 - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::handleGatewayMessage(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::ioErc20(inner) => { - ::abi_encoded_size(inner) - } - Self::pool(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::handleGatewayMessage(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::ioErc20(inner) => { - ::abi_encode_raw(inner, out) - } - Self::pool(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - ///Container for all the [`IonicStrategy`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum IonicStrategyEvents { - #[allow(missing_docs)] - TokenOutput(TokenOutput), - } - #[automatically_derived] - impl IonicStrategyEvents { - /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for IonicStrategyEvents { - const NAME: &'static str = "IonicStrategyEvents"; - const COUNT: usize = 1usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::TokenOutput) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 IonicStrategyEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`IonicStrategy`](self) contract instance. - -See the [wrapper's documentation](`IonicStrategyInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> IonicStrategyInstance { - IonicStrategyInstance::::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: alloy_contract::private::Network, - >( - provider: P, - _ioErc20: alloy::sol_types::private::Address, - _pool: alloy::sol_types::private::Address, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - IonicStrategyInstance::::deploy(provider, _ioErc20, _pool) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - _ioErc20: alloy::sol_types::private::Address, - _pool: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - IonicStrategyInstance::::deploy_builder(provider, _ioErc20, _pool) - } - /**A [`IonicStrategy`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`IonicStrategy`](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 IonicStrategyInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for IonicStrategyInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("IonicStrategyInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IonicStrategyInstance { - /**Creates a new wrapper around an on-chain [`IonicStrategy`](self) contract instance. - -See the [wrapper's documentation](`IonicStrategyInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - _ioErc20: alloy::sol_types::private::Address, - _pool: alloy::sol_types::private::Address, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder(provider, _ioErc20, _pool); - 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, - _ioErc20: alloy::sol_types::private::Address, - _pool: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { _ioErc20, _pool }, - )[..], - ] - .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 IonicStrategyInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> IonicStrategyInstance { - IonicStrategyInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IonicStrategyInstance { - /// 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( - &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 [`handleGatewayMessage`] function. - pub fn handleGatewayMessage( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - message: alloy::sol_types::private::Bytes, - ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { - self.call_builder( - &handleGatewayMessageCall { - tokenSent, - amountIn, - recipient, - message, - }, - ) - } - ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. - pub fn handleGatewayMessageWithSlippageArgs( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - args: ::RustType, - ) -> alloy_contract::SolCallBuilder< - &P, - handleGatewayMessageWithSlippageArgsCall, - N, - > { - self.call_builder( - &handleGatewayMessageWithSlippageArgsCall { - tokenSent, - amountIn, - recipient, - args, - }, - ) - } - ///Creates a new call builder for the [`ioErc20`] function. - pub fn ioErc20(&self) -> alloy_contract::SolCallBuilder<&P, ioErc20Call, N> { - self.call_builder(&ioErc20Call) - } - ///Creates a new call builder for the [`pool`] function. - pub fn pool(&self) -> alloy_contract::SolCallBuilder<&P, poolCall, N> { - self.call_builder(&poolCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IonicStrategyInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`TokenOutput`] event. - pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/ionic_strategy_forked.rs b/crates/bindings/src/ionic_strategy_forked.rs deleted file mode 100644 index b3569a814..000000000 --- a/crates/bindings/src/ionic_strategy_forked.rs +++ /dev/null @@ -1,7991 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface IonicStrategyForked { - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function setUp() external; - function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function testIonicStrategy() external; - function token() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "setUp", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "simulateForkAndTransfer", - "inputs": [ - { - "name": "forkAtBlock", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "sender", - "type": "address", - "internalType": "address" - }, - { - "name": "receiver", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testIonicStrategy", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "token", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IERC20" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 IonicStrategyForked { - use super::*; - use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15`+W__\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16t\xBB\xA2\xEF\x94]R^<#\x11a\0\xCEW\x80c>^<#\x14a\x01DW\x80c?r\x86\xF4\x14a\x01LW\x80cf\xD9\xA9\xA0\x14a\x01TW\x80c\x85\"l\x81\x14a\x01iW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x1B\x8F\xFF@\x14a\x01\tW\x80c\x1E\xD7\x83\x1C\x14a\x01\x11W\x80c*\xDE8\x80\x14a\x01/W[__\xFD[a\x01\x07a\x02-V[\0[a\x01\x07a\x02nV[a\x01\x19a\x05\xE1V[`@Qa\x01&\x91\x90a\x11\xA3V[`@Q\x80\x91\x03\x90\xF3[a\x017a\x06NV[`@Qa\x01&\x91\x90a\x12)V[a\x01\x19a\x07\x97V[a\x01\x19a\x08\x02V[a\x01\\a\x08mV[`@Qa\x01&\x91\x90a\x13yV[a\x01qa\t\xE6V[`@Qa\x01&\x91\x90a\x13\xF7V[a\x01\x86a\n\xB1V[`@Qa\x01&\x91\x90a\x14NV[a\x01\x86a\x0B\xB4V[a\x01qa\x0C\xB7V[a\x01\xABa\r\x82V[`@Q\x90\x15\x15\x81R` \x01a\x01&V[a\x01\x19a\x0ERV[a\x01\x07a\x01\xD16`\x04a\x14\xFAV[a\x0E\xBDV[`\x1FTa\x01\xAB\x90`\xFF\x16\x81V[`\x1FTa\x02\x08\x90a\x01\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[`@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&V[a\x02lb\\\xBA\x95s\xA7\x9A5k\x01\xEF\x80[0\x89\xB4\xFEgD{\x96\xC7\xE6\xDDLs\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Eg\r\xE0\xB6\xB3\xA7d\0\0a\x0E\xBDV[V[`@Qsh\xE0\xE4\xD8u\xFD\xE3O\xC4i\x8F@\xCC\xCA\r\xB5\xB6~6\x93\x90s\x9C\xFE\xE8\x19p\xAA\x10\xCCY;\x83\xFB\x96\xEA\xA9\x88\nm\xF7\x15\x90_\x90\x83\x90\x83\x90a\x02\xAC\x90a\x11\x96V[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x02\xE9W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x03cW__\xFD[PZ\xF1\x15\x80\x15a\x03uW=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\xFCW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04 \x91\x90a\x15;V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xB8W__\xFD[PZ\xF1\x15\x80\x15a\x04\xCAW=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05'W__\xFD[PZ\xF1\x15\x80\x15a\x059W=__>=_\xFD[PP`@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\x81R`\x01`\x04\x82\x01Ra\x05\xDC\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xAAW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xCE\x91\x90a\x15aV[gEc\x91\x81\xFF1}ca\x11\x13V[PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06DW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x06\x19W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x07wW\x83\x82\x90_R` _ \x01\x80Ta\x06\xEC\x90a\x15xV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07\x18\x90a\x15xV[\x80\x15a\x07cW\x80`\x1F\x10a\x07:Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07cV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07FW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x06\xCFV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x06qV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06DW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x06\x19WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06DW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x06\x19WPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x08\xC0\x90a\x15xV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x08\xEC\x90a\x15xV[\x80\x15a\t7W\x80`\x1F\x10a\t\x0EWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\t7V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t\x1AW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\t\xCEW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\t{W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x08\x90V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW\x83\x82\x90_R` _ \x01\x80Ta\n&\x90a\x15xV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\nR\x90a\x15xV[\x80\x15a\n\x9DW\x80`\x1F\x10a\ntWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\x9DV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\n\x80W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\n\tV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0B\x9CW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0BIW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\n\xD4V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\x9FW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0CLW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0B\xD7V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW\x83\x82\x90_R` _ \x01\x80Ta\x0C\xF7\x90a\x15xV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r#\x90a\x15xV[\x80\x15a\rnW\x80`\x1F\x10a\rEWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rnV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\rQW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xDAV[`\x08T_\x90`\xFF\x16\x15a\r\x99WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E'W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0EK\x91\x90a\x15aV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06DW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x06\x19WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0FXW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x0F\x7F\x91\x90\x81\x01\x90a\x15\xF6V[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0F\x9D\x92\x91\x90a\x16\xAAV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0F\xB9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xDD\x91\x90a\x15aV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10VW__\xFD[PZ\xF1\x15\x80\x15a\x10hW=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10\xE8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\x0C\x91\x90a\x15;V[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x11|W__\xFD[PZ\xFA\x15\x80\x15a\x11\x8EW=__>=_\xFD[PPPPPPV[a\x11.\x80a\x16\xCC\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x11\xF0W\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\x11\xBCV[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x11W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x12\xF7W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x12\xE1\x84\x86Qa\x11\xFBV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x12\xA7V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x12OV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x13oW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x13/V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x11W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x13\xC5`@\x88\x01\x82a\x11\xFBV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x13\xE0\x81\x83a\x13\x1DV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x13\x9FV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x11W`?\x19\x87\x86\x03\x01\x84Ra\x149\x85\x83Qa\x11\xFBV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\x1DV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x11W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x14\xBC`@\x87\x01\x82a\x13\x1DV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14tV[\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\xF5W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x15\rW__\xFD[\x845\x93Pa\x15\x1D` \x86\x01a\x14\xD2V[\x92Pa\x15+`@\x86\x01a\x14\xD2V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[_` \x82\x84\x03\x12\x15a\x15KW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x15ZW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x15qW__\xFD[PQ\x91\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x15\x8CW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x15\xC3W\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[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\x16\x06W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\x1CW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x16,W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16FWa\x16Fa\x15\xC9V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x16vWa\x16va\x15\xC9V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x16\x8DW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x16\xBC`@\x83\x01\x85a\x11\xFBV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x11.8\x03\x80a\x11.\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x10Qa\0\xDD_9_\x81\x81`S\x01Ra\x02\xD1\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xBF\x01R\x81\x81a\x02S\x01R\x81\x81a\x03\xE8\x01Ra\x05\xD4\x01Ra\x10Q_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x16\xF0\x11[\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xF6s\xF0\xD9\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\x0C\xB1V[a\0\xEDV[\0[a\0\xB1a\0\xC16`\x04a\rsV[a\x01\x17V[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[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\r\xF7V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x07LV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x08\x10V[`@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\x83\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\x91_\x91\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0E\x1BV[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R\x91\x92P_\x91\x90` \x80\x83\x01\x90\x806\x837\x01\x90PP\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\x81_\x81Q\x81\x10a\x02\x84Wa\x02\x84a\x0E2V[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`@Q\x7F\xC2\x99\x828\0\0\0\0\0\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\x7F\0\0\0\0\0\0\0\0\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\xC2\x99\x828\x90a\x03\x06\x90\x85\x90`\x04\x01a\x0E_V[_`@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03!W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x03H\x91\x90\x81\x01\x90a\x0E\xB7V[\x90P\x80_\x81Q\x81\x10a\x03\\Wa\x03\\a\x0E2V[` \x02` \x01\x01Q_\x14a\x03\xB7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FCouldn't enter in Market\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@Q\x7F\xA0q-h\0\0\0\0\0\0\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\x88\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\xA0q-h\x90`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04g\x91\x90a\x0E\x1BV[\x90P\x80\x15a\x04\xDCW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FCould not mint token in Ionic ma`D\x82\x01R\x7Frket\0\0\0\0\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\x03\xAEV[`@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\x87\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05j\x91\x90a\x0E\x1BV[\x90Pa\x05\x8Ds\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x89\x83a\t\x0BV[`@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\x89\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\x1BW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06?\x91\x90a\x0E\x1BV[\x90P\x85\x81\x11a\x06\x90W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01a\x03\xAEV[_a\x06\x9B\x87\x83a\x0F\x85V[\x89Q\x90\x91P\x81\x10\x15a\x06\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xAEV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8A\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x08\n\x90\x85\x90\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\x90`\x84\x01[`@\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\tfV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x84W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\xA8\x91\x90a\x0E\x1BV[a\x08\xB2\x91\x90a\x0F\x9EV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x08\n\x90\x85\x90\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\x90`d\x01a\x07\xA6V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\ta\x90\x84\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\x90`d\x01a\x07\xA6V[PPPV[_a\t\xC7\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\nW\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\taW\x80\x80` \x01\x90Q\x81\x01\x90a\t\xE5\x91\x90a\x0F\xB1V[a\taW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xAEV[``a\ne\x84\x84_\x85a\noV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\n\xE7W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xAEV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x0BKW`@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\x03\xAEV[__\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\x0Bs\x91\x90a\x0F\xD0V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x0B\xADW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x0B\xB2V[``\x91P[P\x91P\x91Pa\x0B\xC2\x82\x82\x86a\x0B\xCDV[\x97\x96PPPPPPPV[``\x83\x15a\x0B\xDCWP\x81a\nhV[\x82Q\x15a\x0B\xECW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xAE\x91\x90a\x0F\xE6V[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\x0C'W__\xFD[PV[\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\x0CzWa\x0Cza\x0C*V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0C\xA9Wa\x0C\xA9a\x0C*V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0C\xC4W__\xFD[\x845a\x0C\xCF\x81a\x0C\x06V[\x93P` \x85\x015\x92P`@\x85\x015a\x0C\xE6\x81a\x0C\x06V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\x01W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\r\x11W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r+Wa\r+a\x0C*V[a\r>` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0C\x80V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\rRW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\r\x87W__\xFD[\x855a\r\x92\x81a\x0C\x06V[\x94P` \x86\x015\x93P`@\x86\x015a\r\xA9\x81a\x0C\x06V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\r\xDAW__\xFD[Pa\r\xE3a\x0CWV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0E\x08W__\xFD[Pa\x0E\x11a\x0CWV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0E+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[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x0E\xACW\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\x0ExV[P\x90\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x0E\xC7W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0E\xDDW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x0E\xEDW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0F\x07Wa\x0F\x07a\x0C*V[\x80`\x05\x1Ba\x0F\x17` \x82\x01a\x0C\x80V[\x91\x82R` \x81\x84\x01\x81\x01\x92\x90\x81\x01\x90\x87\x84\x11\x15a\x0F2W__\xFD[` \x85\x01\x94P[\x83\x85\x10\x15a\x0B\xC2W\x84Q\x80\x83R` \x95\x86\x01\x95\x90\x93P\x90\x91\x01\x90a\x0F9V[\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\x0F\x98Wa\x0F\x98a\x0FXV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0F\x98Wa\x0F\x98a\x0FXV[_` \x82\x84\x03\x12\x15a\x0F\xC1W__\xFD[\x81Q\x80\x15\x15\x81\x14a\nhW__\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\xFE\xA2dipfsX\"\x12 \xA63\xC5\xE5\xEB@\xCE\xD5\xA8\xAC\xC4\xC9\xF1HKy%\x82\xCD\xE3]\xB9\xCEE\xC8l\xF1O\x15\xEA\xD7\xF0dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 Cw\x8D\x87x\xB9]iA\xFE\x1EsL$\xDD\rW\x187\xCE\xEB\x0F).r\xFD~YSN\x9D\x1BdsolcC\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\0\xFBW_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\x93W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x01\xBBW\x80c\xF9\xCE\x0EZ\x14a\x01\xC3W\x80c\xFAv&\xD4\x14a\x01\xD6W\x80c\xFC\x0CTj\x14a\x01\xE3W__\xFD[\x80c\x91j\x17\xC6\x14a\x01~W\x80c\xB0FO\xDC\x14a\x01\x93W\x80c\xB5P\x8A\xA9\x14a\x01\x9BW\x80c\xBAAO\xA6\x14a\x01\xA3W__\xFD[\x80c>^<#\x11a\0\xCEW\x80c>^<#\x14a\x01DW\x80c?r\x86\xF4\x14a\x01LW\x80cf\xD9\xA9\xA0\x14a\x01TW\x80c\x85\"l\x81\x14a\x01iW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x1B\x8F\xFF@\x14a\x01\tW\x80c\x1E\xD7\x83\x1C\x14a\x01\x11W\x80c*\xDE8\x80\x14a\x01/W[__\xFD[a\x01\x07a\x02-V[\0[a\x01\x07a\x02nV[a\x01\x19a\x05\xE1V[`@Qa\x01&\x91\x90a\x11\xA3V[`@Q\x80\x91\x03\x90\xF3[a\x017a\x06NV[`@Qa\x01&\x91\x90a\x12)V[a\x01\x19a\x07\x97V[a\x01\x19a\x08\x02V[a\x01\\a\x08mV[`@Qa\x01&\x91\x90a\x13yV[a\x01qa\t\xE6V[`@Qa\x01&\x91\x90a\x13\xF7V[a\x01\x86a\n\xB1V[`@Qa\x01&\x91\x90a\x14NV[a\x01\x86a\x0B\xB4V[a\x01qa\x0C\xB7V[a\x01\xABa\r\x82V[`@Q\x90\x15\x15\x81R` \x01a\x01&V[a\x01\x19a\x0ERV[a\x01\x07a\x01\xD16`\x04a\x14\xFAV[a\x0E\xBDV[`\x1FTa\x01\xAB\x90`\xFF\x16\x81V[`\x1FTa\x02\x08\x90a\x01\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[`@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&V[a\x02lb\\\xBA\x95s\xA7\x9A5k\x01\xEF\x80[0\x89\xB4\xFEgD{\x96\xC7\xE6\xDDLs\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Eg\r\xE0\xB6\xB3\xA7d\0\0a\x0E\xBDV[V[`@Qsh\xE0\xE4\xD8u\xFD\xE3O\xC4i\x8F@\xCC\xCA\r\xB5\xB6~6\x93\x90s\x9C\xFE\xE8\x19p\xAA\x10\xCCY;\x83\xFB\x96\xEA\xA9\x88\nm\xF7\x15\x90_\x90\x83\x90\x83\x90a\x02\xAC\x90a\x11\x96V[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x02\xE9W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x03cW__\xFD[PZ\xF1\x15\x80\x15a\x03uW=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\xFCW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04 \x91\x90a\x15;V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xB8W__\xFD[PZ\xF1\x15\x80\x15a\x04\xCAW=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05'W__\xFD[PZ\xF1\x15\x80\x15a\x059W=__>=_\xFD[PP`@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\x81R`\x01`\x04\x82\x01Ra\x05\xDC\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xAAW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xCE\x91\x90a\x15aV[gEc\x91\x81\xFF1}ca\x11\x13V[PPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06DW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x06\x19W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x07wW\x83\x82\x90_R` _ \x01\x80Ta\x06\xEC\x90a\x15xV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x07\x18\x90a\x15xV[\x80\x15a\x07cW\x80`\x1F\x10a\x07:Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07cV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07FW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x06\xCFV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x06qV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06DW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x06\x19WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06DW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x06\x19WPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x08\xC0\x90a\x15xV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x08\xEC\x90a\x15xV[\x80\x15a\t7W\x80`\x1F\x10a\t\x0EWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\t7V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\t\x1AW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\t\xCEW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\t{W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x08\x90V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW\x83\x82\x90_R` _ \x01\x80Ta\n&\x90a\x15xV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\nR\x90a\x15xV[\x80\x15a\n\x9DW\x80`\x1F\x10a\ntWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\x9DV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\n\x80W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\n\tV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0B\x9CW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0BIW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\n\xD4V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\x9FW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0CLW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0B\xD7V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x07\x8EW\x83\x82\x90_R` _ \x01\x80Ta\x0C\xF7\x90a\x15xV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r#\x90a\x15xV[\x80\x15a\rnW\x80`\x1F\x10a\rEWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rnV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\rQW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xDAV[`\x08T_\x90`\xFF\x16\x15a\r\x99WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E'W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0EK\x91\x90a\x15aV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06DW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x06\x19WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0FXW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x0F\x7F\x91\x90\x81\x01\x90a\x15\xF6V[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0F\x9D\x92\x91\x90a\x16\xAAV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0F\xB9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xDD\x91\x90a\x15aV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10VW__\xFD[PZ\xF1\x15\x80\x15a\x10hW=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10\xE8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\x0C\x91\x90a\x15;V[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x11|W__\xFD[PZ\xFA\x15\x80\x15a\x11\x8EW=__>=_\xFD[PPPPPPV[a\x11.\x80a\x16\xCC\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x11\xF0W\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\x11\xBCV[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x11W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x12\xF7W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x12\xE1\x84\x86Qa\x11\xFBV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x12\xA7V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x12OV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x13oW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x13/V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x11W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x13\xC5`@\x88\x01\x82a\x11\xFBV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x13\xE0\x81\x83a\x13\x1DV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x13\x9FV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x11W`?\x19\x87\x86\x03\x01\x84Ra\x149\x85\x83Qa\x11\xFBV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\x1DV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x11W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x14\xBC`@\x87\x01\x82a\x13\x1DV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14tV[\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\xF5W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x15\rW__\xFD[\x845\x93Pa\x15\x1D` \x86\x01a\x14\xD2V[\x92Pa\x15+`@\x86\x01a\x14\xD2V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[_` \x82\x84\x03\x12\x15a\x15KW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x15ZW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x15qW__\xFD[PQ\x91\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x15\x8CW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x15\xC3W\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[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\x16\x06W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\x1CW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x16,W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16FWa\x16Fa\x15\xC9V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x16vWa\x16va\x15\xC9V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x16\x8DW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x16\xBC`@\x83\x01\x85a\x11\xFBV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x11.8\x03\x80a\x11.\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x10Qa\0\xDD_9_\x81\x81`S\x01Ra\x02\xD1\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xBF\x01R\x81\x81a\x02S\x01R\x81\x81a\x03\xE8\x01Ra\x05\xD4\x01Ra\x10Q_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x16\xF0\x11[\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xF6s\xF0\xD9\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\x0C\xB1V[a\0\xEDV[\0[a\0\xB1a\0\xC16`\x04a\rsV[a\x01\x17V[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[_\x81\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\r\xF7V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x07LV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x08\x10V[`@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\x83\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\x91_\x91\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02,\x91\x90a\x0E\x1BV[`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R\x91\x92P_\x91\x90` \x80\x83\x01\x90\x806\x837\x01\x90PP\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\x81_\x81Q\x81\x10a\x02\x84Wa\x02\x84a\x0E2V[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`@Q\x7F\xC2\x99\x828\0\0\0\0\0\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\x7F\0\0\0\0\0\0\0\0\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\xC2\x99\x828\x90a\x03\x06\x90\x85\x90`\x04\x01a\x0E_V[_`@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03!W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x03H\x91\x90\x81\x01\x90a\x0E\xB7V[\x90P\x80_\x81Q\x81\x10a\x03\\Wa\x03\\a\x0E2V[` \x02` \x01\x01Q_\x14a\x03\xB7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FCouldn't enter in Market\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@Q\x7F\xA0q-h\0\0\0\0\0\0\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\x88\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\xA0q-h\x90`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04g\x91\x90a\x0E\x1BV[\x90P\x80\x15a\x04\xDCW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FCould not mint token in Ionic ma`D\x82\x01R\x7Frket\0\0\0\0\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\x03\xAEV[`@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\x87\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05j\x91\x90a\x0E\x1BV[\x90Pa\x05\x8Ds\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x89\x83a\t\x0BV[`@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\x89\x81\x16`\x04\x83\x01R_\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\x90\x91\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\x1BW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06?\x91\x90a\x0E\x1BV[\x90P\x85\x81\x11a\x06\x90W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01a\x03\xAEV[_a\x06\x9B\x87\x83a\x0F\x85V[\x89Q\x90\x91P\x81\x10\x15a\x06\xEFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\xAEV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x8A\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x08\n\x90\x85\x90\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\x90`\x84\x01[`@\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\tfV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x84W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\xA8\x91\x90a\x0E\x1BV[a\x08\xB2\x91\x90a\x0F\x9EV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x08\n\x90\x85\x90\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\x90`d\x01a\x07\xA6V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\ta\x90\x84\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\x90`d\x01a\x07\xA6V[PPPV[_a\t\xC7\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\nW\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\taW\x80\x80` \x01\x90Q\x81\x01\x90a\t\xE5\x91\x90a\x0F\xB1V[a\taW`@QbF\x1B\xCD`\xE5\x1B\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\x03\xAEV[``a\ne\x84\x84_\x85a\noV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\n\xE7W`@QbF\x1B\xCD`\xE5\x1B\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\x03\xAEV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x0BKW`@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\x03\xAEV[__\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\x0Bs\x91\x90a\x0F\xD0V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x0B\xADW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x0B\xB2V[``\x91P[P\x91P\x91Pa\x0B\xC2\x82\x82\x86a\x0B\xCDV[\x97\x96PPPPPPPV[``\x83\x15a\x0B\xDCWP\x81a\nhV[\x82Q\x15a\x0B\xECW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\xAE\x91\x90a\x0F\xE6V[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\x0C'W__\xFD[PV[\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\x0CzWa\x0Cza\x0C*V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0C\xA9Wa\x0C\xA9a\x0C*V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0C\xC4W__\xFD[\x845a\x0C\xCF\x81a\x0C\x06V[\x93P` \x85\x015\x92P`@\x85\x015a\x0C\xE6\x81a\x0C\x06V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\x01W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\r\x11W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r+Wa\r+a\x0C*V[a\r>` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0C\x80V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\rRW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\r\x87W__\xFD[\x855a\r\x92\x81a\x0C\x06V[\x94P` \x86\x015\x93P`@\x86\x015a\r\xA9\x81a\x0C\x06V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\r\xDAW__\xFD[Pa\r\xE3a\x0CWV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0E\x08W__\xFD[Pa\x0E\x11a\x0CWV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0E+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[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x0E\xACW\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\x0ExV[P\x90\x95\x94PPPPPV[_` \x82\x84\x03\x12\x15a\x0E\xC7W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0E\xDDW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x0E\xEDW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0F\x07Wa\x0F\x07a\x0C*V[\x80`\x05\x1Ba\x0F\x17` \x82\x01a\x0C\x80V[\x91\x82R` \x81\x84\x01\x81\x01\x92\x90\x81\x01\x90\x87\x84\x11\x15a\x0F2W__\xFD[` \x85\x01\x94P[\x83\x85\x10\x15a\x0B\xC2W\x84Q\x80\x83R` \x95\x86\x01\x95\x90\x93P\x90\x91\x01\x90a\x0F9V[\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\x0F\x98Wa\x0F\x98a\x0FXV[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0F\x98Wa\x0F\x98a\x0FXV[_` \x82\x84\x03\x12\x15a\x0F\xC1W__\xFD[\x81Q\x80\x15\x15\x81\x14a\nhW__\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\xFE\xA2dipfsX\"\x12 \xA63\xC5\xE5\xEB@\xCE\xD5\xA8\xAC\xC4\xC9\xF1HKy%\x82\xCD\xE3]\xB9\xCEE\xC8l\xF1O\x15\xEA\xD7\xF0dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 Cw\x8D\x87x\xB9]iA\xFE\x1EsL$\xDD\rW\x187\xCE\xEB\x0F).r\xFD~YSN\x9D\x1BdsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. -```solidity -event log(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `setUp()` and selector `0x0a9254e4`. -```solidity -function setUp() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setUpCall; - ///Container type for the return parameters of the [`setUp()`](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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl setUpReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for setUpCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = setUpReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "setUp()"; - const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - setUpReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. -```solidity -function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferCall { - #[allow(missing_docs)] - pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub sender: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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::Uint<256>, - ); - #[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::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferCall) -> Self { - (value.forkAtBlock, value.sender, value.receiver, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - forkAtBlock: tuple.0, - sender: tuple.1, - receiver: tuple.2, - amount: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl simulateForkAndTransferReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for simulateForkAndTransferCall { - type Parameters<'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::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = simulateForkAndTransferReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; - const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), - ::tokenize( - &self.sender, - ), - ::tokenize( - &self.receiver, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - simulateForkAndTransferReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testIonicStrategy()` and selector `0x1b8fff40`. -```solidity -function testIonicStrategy() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIonicStrategyCall; - ///Container type for the return parameters of the [`testIonicStrategy()`](testIonicStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testIonicStrategyReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIonicStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIonicStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testIonicStrategyReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testIonicStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testIonicStrategyReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testIonicStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testIonicStrategyReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testIonicStrategy()"; - const SELECTOR: [u8; 4] = [27u8, 143u8, 255u8, 64u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testIonicStrategyReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `token()` and selector `0xfc0c546a`. -```solidity -function token() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`token()`](tokenCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for tokenCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "token()"; - const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`IonicStrategyForked`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum IonicStrategyForkedCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - setUp(setUpCall), - #[allow(missing_docs)] - simulateForkAndTransfer(simulateForkAndTransferCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - testIonicStrategy(testIonicStrategyCall), - #[allow(missing_docs)] - token(tokenCall), - } - #[automatically_derived] - impl IonicStrategyForkedCalls { - /// 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]] = &[ - [10u8, 146u8, 84u8, 228u8], - [27u8, 143u8, 255u8, 64u8], - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [102u8, 217u8, 169u8, 160u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [226u8, 12u8, 159u8, 113u8], - [249u8, 206u8, 14u8, 90u8], - [250u8, 118u8, 38u8, 212u8], - [252u8, 12u8, 84u8, 106u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for IonicStrategyForkedCalls { - const NAME: &'static str = "IonicStrategyForkedCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 16usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::setUp(_) => ::SELECTOR, - Self::simulateForkAndTransfer(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::testIonicStrategy(_) => { - ::SELECTOR - } - Self::token(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IonicStrategyForkedCalls::setUp) - } - setUp - }, - { - fn testIonicStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IonicStrategyForkedCalls::testIonicStrategy) - } - testIonicStrategy - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IonicStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IonicStrategyForkedCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IonicStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IonicStrategyForkedCalls::targetContracts) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IonicStrategyForkedCalls::targetArtifactSelectors) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IonicStrategyForkedCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IonicStrategyForkedCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IonicStrategyForkedCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IonicStrategyForkedCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IonicStrategyForkedCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IonicStrategyForkedCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(IonicStrategyForkedCalls::simulateForkAndTransfer) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IonicStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(IonicStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IonicStrategyForkedCalls::setUp) - } - setUp - }, - { - fn testIonicStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IonicStrategyForkedCalls::testIonicStrategy) - } - testIonicStrategy - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IonicStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IonicStrategyForkedCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IonicStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IonicStrategyForkedCalls::targetContracts) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IonicStrategyForkedCalls::targetArtifactSelectors) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IonicStrategyForkedCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IonicStrategyForkedCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IonicStrategyForkedCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IonicStrategyForkedCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IonicStrategyForkedCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IonicStrategyForkedCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IonicStrategyForkedCalls::simulateForkAndTransfer) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IonicStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(IonicStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::setUp(inner) => { - ::abi_encoded_size(inner) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testIonicStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::token(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::setUp(inner) => { - ::abi_encode_raw(inner, out) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testIonicStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::token(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - ///Container for all the [`IonicStrategyForked`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum IonicStrategyForkedEvents { - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl IonicStrategyForkedEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for IonicStrategyForkedEvents { - const NAME: &'static str = "IonicStrategyForkedEvents"; - const COUNT: usize = 22usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 IonicStrategyForkedEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`IonicStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`IonicStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> IonicStrategyForkedInstance { - IonicStrategyForkedInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - IonicStrategyForkedInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - IonicStrategyForkedInstance::::deploy_builder(provider) - } - /**A [`IonicStrategyForked`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`IonicStrategyForked`](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 IonicStrategyForkedInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for IonicStrategyForkedInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("IonicStrategyForkedInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IonicStrategyForkedInstance { - /**Creates a new wrapper around an on-chain [`IonicStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`IonicStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 IonicStrategyForkedInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> IonicStrategyForkedInstance { - IonicStrategyForkedInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IonicStrategyForkedInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`setUp`] function. - pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { - self.call_builder(&setUpCall) - } - ///Creates a new call builder for the [`simulateForkAndTransfer`] function. - pub fn simulateForkAndTransfer( - &self, - forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - sender: alloy::sol_types::private::Address, - receiver: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { - self.call_builder( - &simulateForkAndTransferCall { - forkAtBlock, - sender, - receiver, - amount, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`testIonicStrategy`] function. - pub fn testIonicStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testIonicStrategyCall, N> { - self.call_builder(&testIonicStrategyCall) - } - ///Creates a new call builder for the [`token`] function. - pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { - self.call_builder(&tokenCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IonicStrategyForkedInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/lib.rs b/crates/bindings/src/lib.rs index 3b142347a..a9b17e504 100644 --- a/crates/bindings/src/lib.rs +++ b/crates/bindings/src/lib.rs @@ -1,87 +1,9 @@ -#![allow(unused_imports, clippy::all, dead_code, rustdoc::all)] +#![allow(unused_imports, clippy::all, rustdoc::all)] //! 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. -pub mod r#address; -pub mod r#avalon_lending_strategy; -pub mod r#avalon_lst_strategy; -pub mod r#dummy_avalon_pool_implementation; -pub mod r#i_avalon_i_pool; -pub mod r#avalon_tbtc_lending_strategy_forked; -pub mod r#avalon_wbtc_lending_strategy_forked; -pub mod r#avalon_wbtc_lst_strategy_forked; -pub mod r#btc_utils; -pub mod r#bedrock_strategy; -pub mod r#dummy_bedrock_vault_implementation; -pub mod r#i_bedrock_vault; -pub mod r#bedrock_strategy_forked; -pub mod r#bitcoin_tx; -pub mod r#btc_market_place; -pub mod r#arbitary_erc20; -pub mod r#bytes_lib; -pub mod r#constants; -pub mod r#context; -pub mod r#erc20; -pub mod r#erc2771_recipient; -pub mod r#forked_strategy_template_tbtc; -pub mod r#forked_strategy_template_wbtc; pub mod r#full_relay; pub mod r#full_relay_with_verify; -pub mod r#hybrid_btc_strategy; -pub mod r#i_teller; -pub mod r#hybrid_btc_strategy_forked_wbtc; -pub mod r#ierc20; -pub mod r#ierc20_metadata; -pub mod r#ierc2771_recipient; pub mod r#i_full_relay; pub mod r#i_full_relay_with_verify; -pub mod r#i_light_relay; -pub mod r#i_strategy; -pub mod r#i_strategy_with_slippage_args; -pub mod r#dummy_ionic_pool; -pub mod r#dummy_ionic_token; -pub mod r#i_ionic_token; -pub mod r#i_pool; -pub mod r#ionic_strategy; -pub mod r#ionic_strategy_forked; -pub mod r#light_relay; -pub mod r#relay_utils; -pub mod r#market_place; -pub mod r#ord_marketplace; -pub mod r#ownable; -pub mod r#dummy_pell_strategy; -pub mod r#dummy_pell_strategy_manager; -pub mod r#i_pell_strategy; -pub mod r#i_pell_strategy_manager; -pub mod r#pell_bedrock_strategy; -pub mod r#pell_solv_lst_strategy; -pub mod r#pell_strategy; -pub mod r#pell_bed_rock_lst_strategy_forked; -pub mod r#pell_bed_rock_strategy_forked; -pub mod r#pell_strategy_forked; -pub mod r#safe_erc20; -pub mod r#safe_math; -pub mod r#seg_wit_utils; -pub mod r#dummy_se_bep20; -pub mod r#i_se_bep20; -pub mod r#segment_bedrock_strategy; -pub mod r#segment_solv_lst_strategy; -pub mod r#segment_strategy; -pub mod r#segment_bedrock_and_lst_strategy_forked; -pub mod r#segment_strategy_forked; -pub mod r#dummy_shoe_bill_token; -pub mod r#ic_erc20; -pub mod r#shoebill_strategy; -pub mod r#shoebill_tbtc_strategy_forked; -pub mod r#dummy_solv_router; -pub mod r#i_solv_btc_router; -pub mod r#solv_btc_strategy; -pub mod r#solv_lst_strategy; -pub mod r#solv_strategy_forked; -pub mod r#std_constants; -pub mod r#strings; -pub mod r#bitcoin_tx_builder; -pub mod r#utilities; -pub mod r#validate_spv; -pub mod r#witness_tx; diff --git a/crates/bindings/src/light_relay.rs b/crates/bindings/src/light_relay.rs deleted file mode 100644 index 324658ab2..000000000 --- a/crates/bindings/src/light_relay.rs +++ /dev/null @@ -1,6027 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface LightRelay { - event AuthorizationRequirementChanged(bool newStatus); - event Genesis(uint256 blockHeight); - event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); - event ProofLengthChanged(uint256 newLength); - event Retarget(uint256 oldDifficulty, uint256 newDifficulty); - event SubmitterAuthorized(address submitter); - event SubmitterDeauthorized(address submitter); - - function authorizationRequired() external view returns (bool); - function authorize(address submitter) external; - function currentEpoch() external view returns (uint64); - function deauthorize(address submitter) external; - function genesis(bytes memory genesisHeader, uint256 genesisHeight, uint64 genesisProofLength) external; - function genesisEpoch() external view returns (uint64); - function getBlockDifficulty(uint256 blockNumber) external view returns (uint256); - function getCurrentAndPrevEpochDifficulty() external view returns (uint256 current, uint256 previous); - function getCurrentEpochDifficulty() external view returns (uint256); - function getEpochDifficulty(uint256 epochNumber) external view returns (uint256); - function getPrevEpochDifficulty() external view returns (uint256); - function getRelayRange() external view returns (uint256 relayGenesis, uint256 currentEpochEnd); - function isAuthorized(address) external view returns (bool); - function owner() external view returns (address); - function proofLength() external view returns (uint64); - function ready() external view returns (bool); - function renounceOwnership() external; - function retarget(bytes memory headers) external; - function setAuthorizationStatus(bool status) external; - function setProofLength(uint64 newLength) external; - function transferOwnership(address newOwner) external; - function validateChain(bytes memory headers) external view returns (uint256 startingHeaderTimestamp, uint256 headerCount); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "authorizationRequired", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "authorize", - "inputs": [ - { - "name": "submitter", - "type": "address", - "internalType": "address" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "currentEpoch", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "uint64", - "internalType": "uint64" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "deauthorize", - "inputs": [ - { - "name": "submitter", - "type": "address", - "internalType": "address" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "genesis", - "inputs": [ - { - "name": "genesisHeader", - "type": "bytes", - "internalType": "bytes" - }, - { - "name": "genesisHeight", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "genesisProofLength", - "type": "uint64", - "internalType": "uint64" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "genesisEpoch", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "uint64", - "internalType": "uint64" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getBlockDifficulty", - "inputs": [ - { - "name": "blockNumber", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getCurrentAndPrevEpochDifficulty", - "inputs": [], - "outputs": [ - { - "name": "current", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "previous", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getCurrentEpochDifficulty", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getEpochDifficulty", - "inputs": [ - { - "name": "epochNumber", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getPrevEpochDifficulty", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getRelayRange", - "inputs": [], - "outputs": [ - { - "name": "relayGenesis", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "currentEpochEnd", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "isAuthorized", - "inputs": [ - { - "name": "", - "type": "address", - "internalType": "address" - } - ], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "owner", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "address" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "proofLength", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "uint64", - "internalType": "uint64" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "ready", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "renounceOwnership", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "retarget", - "inputs": [ - { - "name": "headers", - "type": "bytes", - "internalType": "bytes" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "setAuthorizationStatus", - "inputs": [ - { - "name": "status", - "type": "bool", - "internalType": "bool" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "setProofLength", - "inputs": [ - { - "name": "newLength", - "type": "uint64", - "internalType": "uint64" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "transferOwnership", - "inputs": [ - { - "name": "newOwner", - "type": "address", - "internalType": "address" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "validateChain", - "inputs": [ - { - "name": "headers", - "type": "bytes", - "internalType": "bytes" - } - ], - "outputs": [ - { - "name": "startingHeaderTimestamp", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "headerCount", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "AuthorizationRequirementChanged", - "inputs": [ - { - "name": "newStatus", - "type": "bool", - "indexed": false, - "internalType": "bool" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "Genesis", - "inputs": [ - { - "name": "blockHeight", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "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": "ProofLengthChanged", - "inputs": [ - { - "name": "newLength", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "Retarget", - "inputs": [ - { - "name": "oldDifficulty", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "newDifficulty", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "SubmitterAuthorized", - "inputs": [ - { - "name": "submitter", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "SubmitterDeauthorized", - "inputs": [ - { - "name": "submitter", - "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 LightRelay { - use super::*; - use alloy::sol_types as 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[P`\x163`\x1AV[`iV[_\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x01`\x01`\xA0\x1B\x03\x19\x83\x16\x81\x17\x84U`@Q\x91\x90\x92\x16\x92\x83\x91\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x91\x90\xA3PPV[a$\xCB\x80a\0v_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01yW_5`\xE0\x1C\x80cqP\x18\xA6\x11a\0\xD2W\x80c\xB6\xA5\xD7\xDE\x11a\0\x88W\x80c\xF2\xFD\xE3\x8B\x11a\0cW\x80c\xF2\xFD\xE3\x8B\x14a\x03JW\x80c\xF5a\x9F\xDA\x14a\x03]W\x80c\xFE\x9F\xBB\x80\x14a\x03wW__\xFD[\x80c\xB6\xA5\xD7\xDE\x14a\x03\x10W\x80c\xB7\x0Ek\xE6\x14a\x03#W\x80c\xEB\x86\x95\xEF\x14a\x037W__\xFD[\x80c|\xA5\xB1\xDD\x11a\0\xB8W\x80c|\xA5\xB1\xDD\x14a\x02\xB1W\x80c\x8D\xA5\xCB[\x14a\x02\xC4W\x80c\x95A\r+\x14a\x02\xEBW__\xFD[\x80cqP\x18\xA6\x14a\x02pW\x80cvg\x18\x08\x14a\x02xW__\xFD[\x80c'\xC9\x7F\xA5\x11a\x012W\x80cL\xA4\x9FQ\x11a\x01\rW\x80cL\xA4\x9FQ\x14a\x02\x16W\x80cb\x04\x14\xE6\x14a\x02)W\x80cm\xEF\xBF\x80\x14a\x02\x9F\x90M\x8C\xF1\x17S\xC7\x9Bg\xC8%\x9CX V\xD4\xA7\xD8\xAF\x12\x0F\x81%zY\xEE\xB8\x82K\x96\x90` \x01[`@Q\x80\x91\x03\x90\xA1PV[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x0BVW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16_\x81\x81R`\x05` \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\x90Q\x91\x82R\x7Ft\x98\xB9k\xEE\xAB\xEAZ\xD3\x13\x9F\x1A(a\xA0>H\x004%N6\xB1\n\xAE.nB\xAD{Kh\x91\x01a\n\xE5V[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x0C7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[_Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x0C\xA1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FGenesis already performed\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[`P\x83\x14a\x0C\xF1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FInvalid genesis header length\0\0\0`D\x82\x01R`d\x01a\x04lV[a\x0C\xFDa\x07\xE0\x83a\"\xF9V[\x15a\rpW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`%`$\x82\x01R\x7FInvalid height of relay genesis `D\x82\x01R\x7Fblock\0\0\0\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\x04lV[a\x07\xE0\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x10a\r\xCBW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7FProof length excessive\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x11a\x0E$W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FProof length may not be zero\0\0\0\0`D\x82\x01R`d\x01a\x04lV[a\x0E0a\x07\xE0\x83a\"\x9CV[`\x01\x80T\x7F\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\0\0\x16g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x90\x92\x16\x91\x82\x17h\x01\0\0\0\0\0\0\0\0\x92\x90\x92\x02\x91\x90\x91\x17\x90U`@\x80Q` `\x1F\x86\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x84\x81R_\x91a\x0E\xB9\x91\x90\x87\x90\x87\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RPa\x1B~\x92PPPV[\x90P_a\x0E\xFA\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\x91RPa\x1AT\x92PPPV[`@\x80Q\x80\x82\x01\x82Rc\xFF\xFF\xFF\xFF\x92\x83\x16\x80\x82R{\xFF\xFF\xFF\xFF\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\x87\x16` \x80\x85\x01\x91\x82R`\x01Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16_\x90\x81R`\x04\x90\x92R\x95\x81 \x94Q\x91Q\x90\x92\x16d\x01\0\0\0\0\x02\x95\x16\x94\x90\x94\x17\x90\x91U\x82T\x91\x86\x16`\x01`\xB0\x1B\x02\x7F\xFF\xFF\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\x90\x92\x16\x91\x90\x91\x17\x90\x91U\x90Pa\x0F\xA9\x82a\x1B\x89V[`\x02U_\x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x17\x90U`@Q\x7F#\x81\xD1i%U\x1C/\xB1\xA5\xED\xFC\xF4\xFC\xE2\xF6\xD0\x85\xE1\xF8_K\x884\x0C\t\xC9\xD1\x91\xF9\xD4\xE9\x90a\x10\x1C\x90\x86\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA1PPPPPPV[`\x01T_\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82\x10\x15a\x10\x8AW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FEpoch is before relay genesis\0\0\0`D\x82\x01R`d\x01a\x04lV[`\x01Th\x01\0\0\0\0\0\0\0\0\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82\x11\x15a\x11\x17W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FEpoch is not proven to the relay`D\x82\x01R\x7F yet\0\0\0\0\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\x04lV[_\x82\x81R`\x04` R`@\x90 Ta\x03\xA9\x90d\x01\0\0\0\0\x90\x04{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x1B\x89V[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x11\xBAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[a\x11\xC3_a\x1B\xB0V[V[_Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16a\x12.W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FRelay is not ready for use\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[_Tu\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x12\xAFW3_\x90\x81R`\x05` R`@\x90 T`\xFF\x16a\x12\xAFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7FSubmitter unauthorized\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[_Ta\x12\xCD\x90`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02a\"\xAFV[a\x12\xD8\x90`Pa\"\xAFV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81Q\x14a\x131W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FInvalid header length\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[`\x01Th\x01\0\0\0\0\0\0\0\0\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16_\x90\x81R`\x04` R`@\x81 \x80T\x90\x91d\x01\0\0\0\0\x90\x91\x04{\xFF\xFF\xFF\xFF\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\x90\x80[_T`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x14:W_\x80a\x13\xB6\x87a\x13\xB0\x85`Pa#\x1FV[\x86a\x1A\x87V[\x91P\x91P\x84\x81\x14a\x14/W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FInvalid target in pre-retarget h`D\x82\x01R\x7Feaders\0\0\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\x04lV[P\x91P`\x01\x01a\x13\x85V[P_\x80Ta\x14{\x90a\x14_\x90`\x01\x90`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a#6V[a\x14j\x90`Pa\"\xAFV[\x86\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x1B^V[c\xFF\xFF\xFF\xFF\x16\x90PB\x81\x10a\x14\xD2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FEpoch cannot end in the future\0\0`D\x82\x01R`d\x01a\x04lV[\x83T_\x90a\x14\xE8\x90\x85\x90c\xFF\xFF\xFF\xFF\x16\x84a\x1C$V[_\x80T\x91\x92P\x90\x81\x90a\x15\"\x90a\x15\x11\x90`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`Pa\"\xAFV[\x89\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x1B^V[_Tc\xFF\xFF\xFF\xFF\x91\x90\x91\x16\x91P`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16[_Ta\x15_\x90`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02a\"\xAFV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x16eW_\x80a\x15\x81\x8Ba\x07\x90\x85`Pa#\x1FV[\x91P\x91P\x84_\x03a\x15\xE5W\x80\x94P\x80\x86\x16\x81\x14a\x15\xE0W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FInvalid target in new epoch\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[a\x16ZV[\x84\x81\x14a\x16ZW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FUnexpected target change after r`D\x82\x01R\x7Fetarget\0\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\x04lV[P\x95P`\x01\x01a\x15AV[P`\x01`\x08\x90T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01a\x16\x89\x91\x90a\"\xD9V[`\x01\x80Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16h\x01\0\0\0\0\0\0\0\0\x90\x81\x02\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16\x91\x90\x91\x17\x91\x82\x90U`@\x80Q\x80\x82\x01\x82Rc\xFF\xFF\xFF\xFF\x80\x87\x16\x82R{\xFF\xFF\xFF\xFF\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\x89\x16` \x80\x85\x01\x91\x82R\x95\x90\x96\x04\x90\x96\x16_\x90\x81R`\x04\x90\x94R\x91\x83 \x90Q\x93Q\x90\x94\x16d\x01\0\0\0\0\x02\x92\x16\x91\x90\x91\x17\x90\x91U`\x02T\x90a\x17D\x84a\x1B\x89V[`\x03\x83\x90U`\x02\x81\x90U`@\x80Q\x84\x81R` \x81\x01\x83\x90R\x91\x92P\x7F\xA2\x82\xEEy\x8B\x13/\x9D\xC1\x1E\x06\xCDM\x8Ev~V+\xE8p\x96\x02\xCA\x14\xFE\xA7\xAB3\x92\xAC\xBD\xAB\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPPV[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x17\xFCW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16_\x81\x81R`\x05` \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`\x01\x17\x90U\x90Q\x91\x82R\x7F\xD56I\xB4\x92\xF78\xBBY\xD6\x82P\x99\xB5\x95Ps\xEF\xDA\x0B\xF9\xE3\xA7\xAD \xDA\"\xE1\x10\x12.)\x91\x01a\n\xE5V[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x18\xE0W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[_\x80T\x82\x15\x15u\x01\0\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\xFF\xFF\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x17\x90U`@Q\x7F\xD8\x13\xB2H\xD4\x9C\x8B\xF0\x8B\xE2\xB6\x94q&\xDAgc\xDF1\x0B\xEE\xD7\xBE\xA9wVElW'A\x9A\x90a\n\xE5\x90\x83\x15\x15\x81R` \x01\x90V[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x19\xBFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16a\x1AHW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01R\x7Fddress\0\0\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\x04lV[a\x1AQ\x81a\x1B\xB0V[PV[_a\x03\xA9a\x1Aa\x83a\x1C\xB6V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80\x82\x15a\x1A\xE6Wa\x1A\x9A\x85\x85\x85a\x1C\xC2V[a\x1A\xE6W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FInvalid chain\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[a\x1A\xF0\x85\x85a\x1C\xEBV[\x90Pa\x1A\xFE\x85\x85`Pa\x1D\x88V[\x91Pa\x1B\n\x82\x82a\x1D\xADV[a\x1BVW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x0C`$\x82\x01R\x7FInvalid work\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[\x93P\x93\x91PPV[_a\x1Bwa\x1Aaa\x1Bp\x84`Da#VV[\x85\x90a\x1F\x03V[\x93\x92PPPV[_a\x03\xA9\x82_a\x1C\xEBV[_a\x03\xA9{\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\x83a\x1F\x11V[_\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x81\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\x83\x16\x81\x17\x84U`@Q\x91\x90\x92\x16\x92\x83\x91\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x91\x90\xA3PPV[_\x80a\x1C0\x83\x85a\x1F\x1CV[\x90Pa\x1C@b\x12u\0`\x04a\x1F\x11V[\x81\x10\x15a\x1CXWa\x1CUb\x12u\0`\x04a\x1F\x11V[\x90P[a\x1Cfb\x12u\0`\x04a\x1FwV[\x81\x11\x15a\x1C~Wa\x1C{b\x12u\0`\x04a\x1FwV[\x90P[_a\x1C\x96\x82a\x1C\x90\x88b\x01\0\0a\x1F\x11V[\x90a\x1FwV[\x90Pa\x1C\xACb\x01\0\0a\x1C\x90\x83b\x12u\0a\x1F\x11V[\x96\x95PPPPPPV[_a\x03\xA9\x82`Da\x1F\x03V[_\x80a\x1C\xCE\x85\x85a\x1F\xEAV[\x90P\x82\x81\x14a\x1C\xE0W_\x91PPa\x1BwV[P`\x01\x94\x93PPPPV[_\x80a\x1C\xFBa\x1Bp\x84`Ha#VV[`\xE8\x1C\x90P_\x84a\x1D\r\x85`Ka#VV[\x81Q\x81\x10a\x1D\x1DWa\x1D\x1Da#iV[\x01` \x01Q`\xF8\x1C\x90P_a\x1DO\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1Db`\x03\x84a#\x96V[`\xFF\x16\x90Pa\x1Ds\x81a\x01\0a$\x8AV[a\x1D}\x90\x83a#\x1FV[\x97\x96PPPPPPPV[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x82a\x1D\xBAWP_a\x03\xA9V[\x81a\x1E\xFB\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x10\x93\x92PPPV[_a\x1Bw\x83\x83\x01` \x01Q\x90V[_a\x1Bw\x82\x84a\"\x9CV[_\x82\x82\x11\x15a\x1FmW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x04lV[a\x1Bw\x82\x84a#\x0CV[_\x82_\x03a\x1F\x86WP_a\x03\xA9V[a\x1F\x90\x82\x84a#\x1FV[\x90P\x81a\x1F\x9D\x84\x83a\"\x9CV[\x14a\x03\xA9W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x04lV[_a\x1Bwa\x1F\xF9\x83`\x04a#VV[\x84\x01` \x01Q\x90V[_` \x82\x84\x03\x12\x15a \x12W__\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_R`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a VW__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a lW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a |W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a \x96Wa \x96a \x19V[`@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!\x02Wa!\x02a \x19V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a!\x19W__\xFD[\x81` \x84\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a!MW__\xFD[\x91\x90PV[_` \x82\x84\x03\x12\x15a!bW__\xFD[a\x1Bw\x82a!6V[_` \x82\x84\x03\x12\x15a!{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\x14a\x1BwW__\xFD[____``\x85\x87\x03\x12\x15a!\xB1W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a!\xC7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a!\xD7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a!\xEDW__\xFD[\x87` \x82\x84\x01\x01\x11\x15a!\xFEW__\xFD[` \x91\x82\x01\x95P\x93P\x85\x015\x91Pa\"\x18`@\x86\x01a!6V[\x90P\x92\x95\x91\x94P\x92PV[_` \x82\x84\x03\x12\x15a\"3W__\xFD[\x815\x80\x15\x15\x81\x14a\x1BwW__\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`\x12`\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`\x11`\x04R`$_\xFD[_\x82a\"\xAAWa\"\xAAa\"BV[P\x04\x90V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x02\x90\x81\x16\x90\x81\x81\x14a\"\xD2Wa\"\xD2a\"oV[P\x92\x91PPV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x03\xA9Wa\x03\xA9a\"oV[_\x82a#\x07Wa#\x07a\"BV[P\x06\x90V[\x81\x81\x03\x81\x81\x11\x15a\x03\xA9Wa\x03\xA9a\"oV[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x03\xA9Wa\x03\xA9a\"oV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x03\xA9Wa\x03\xA9a\"oV[\x80\x82\x01\x80\x82\x11\x15a\x03\xA9Wa\x03\xA9a\"oV[\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[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x03\xA9Wa\x03\xA9a\"oV[`\x01\x81[`\x01\x84\x11\x15a\x1BVW\x80\x85\x04\x81\x11\x15a#\xCEWa#\xCEa\"oV[`\x01\x84\x16\x15a#\xDCW\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a#\xB3V[_\x82a#\xF8WP`\x01a\x03\xA9V[\x81a$\x04WP_a\x03\xA9V[\x81`\x01\x81\x14a$\x1AW`\x02\x81\x14a$$Wa$@V[`\x01\x91PPa\x03\xA9V[`\xFF\x84\x11\x15a$5Wa$5a\"oV[PP`\x01\x82\x1Ba\x03\xA9V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a$cWP\x81\x81\na\x03\xA9V[a$o_\x19\x84\x84a#\xAFV[\x80_\x19\x04\x82\x11\x15a$\x82Wa$\x82a\"oV[\x02\x93\x92PPPV[_a\x1Bw\x83\x83a#\xEAV\xFE\xA2dipfsX\"\x12 e\x7F\xB9\xDBv0*\xD1\x86\x12>\xAC\x9B\xAC\xE1Wv\x19\xC6t~j\xB9z\x11q\x9FYF\r\x92^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\x01yW_5`\xE0\x1C\x80cqP\x18\xA6\x11a\0\xD2W\x80c\xB6\xA5\xD7\xDE\x11a\0\x88W\x80c\xF2\xFD\xE3\x8B\x11a\0cW\x80c\xF2\xFD\xE3\x8B\x14a\x03JW\x80c\xF5a\x9F\xDA\x14a\x03]W\x80c\xFE\x9F\xBB\x80\x14a\x03wW__\xFD[\x80c\xB6\xA5\xD7\xDE\x14a\x03\x10W\x80c\xB7\x0Ek\xE6\x14a\x03#W\x80c\xEB\x86\x95\xEF\x14a\x037W__\xFD[\x80c|\xA5\xB1\xDD\x11a\0\xB8W\x80c|\xA5\xB1\xDD\x14a\x02\xB1W\x80c\x8D\xA5\xCB[\x14a\x02\xC4W\x80c\x95A\r+\x14a\x02\xEBW__\xFD[\x80cqP\x18\xA6\x14a\x02pW\x80cvg\x18\x08\x14a\x02xW__\xFD[\x80c'\xC9\x7F\xA5\x11a\x012W\x80cL\xA4\x9FQ\x11a\x01\rW\x80cL\xA4\x9FQ\x14a\x02\x16W\x80cb\x04\x14\xE6\x14a\x02)W\x80cm\xEF\xBF\x80\x14a\x02\x9F\x90M\x8C\xF1\x17S\xC7\x9Bg\xC8%\x9CX V\xD4\xA7\xD8\xAF\x12\x0F\x81%zY\xEE\xB8\x82K\x96\x90` \x01[`@Q\x80\x91\x03\x90\xA1PV[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x0BVW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16_\x81\x81R`\x05` \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\x90Q\x91\x82R\x7Ft\x98\xB9k\xEE\xAB\xEAZ\xD3\x13\x9F\x1A(a\xA0>H\x004%N6\xB1\n\xAE.nB\xAD{Kh\x91\x01a\n\xE5V[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x0C7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[_Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x0C\xA1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FGenesis already performed\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[`P\x83\x14a\x0C\xF1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FInvalid genesis header length\0\0\0`D\x82\x01R`d\x01a\x04lV[a\x0C\xFDa\x07\xE0\x83a\"\xF9V[\x15a\rpW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`%`$\x82\x01R\x7FInvalid height of relay genesis `D\x82\x01R\x7Fblock\0\0\0\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\x04lV[a\x07\xE0\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x10a\r\xCBW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7FProof length excessive\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x11a\x0E$W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FProof length may not be zero\0\0\0\0`D\x82\x01R`d\x01a\x04lV[a\x0E0a\x07\xE0\x83a\"\x9CV[`\x01\x80T\x7F\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\0\0\x16g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x90\x92\x16\x91\x82\x17h\x01\0\0\0\0\0\0\0\0\x92\x90\x92\x02\x91\x90\x91\x17\x90U`@\x80Q` `\x1F\x86\x01\x81\x90\x04\x81\x02\x82\x01\x81\x01\x90\x92R\x84\x81R_\x91a\x0E\xB9\x91\x90\x87\x90\x87\x90\x81\x90\x84\x01\x83\x82\x80\x82\x847_\x92\x01\x91\x90\x91RPa\x1B~\x92PPPV[\x90P_a\x0E\xFA\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\x91RPa\x1AT\x92PPPV[`@\x80Q\x80\x82\x01\x82Rc\xFF\xFF\xFF\xFF\x92\x83\x16\x80\x82R{\xFF\xFF\xFF\xFF\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\x87\x16` \x80\x85\x01\x91\x82R`\x01Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16_\x90\x81R`\x04\x90\x92R\x95\x81 \x94Q\x91Q\x90\x92\x16d\x01\0\0\0\0\x02\x95\x16\x94\x90\x94\x17\x90\x91U\x82T\x91\x86\x16`\x01`\xB0\x1B\x02\x7F\xFF\xFF\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\x90\x92\x16\x91\x90\x91\x17\x90\x91U\x90Pa\x0F\xA9\x82a\x1B\x89V[`\x02U_\x80T\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x17\x90U`@Q\x7F#\x81\xD1i%U\x1C/\xB1\xA5\xED\xFC\xF4\xFC\xE2\xF6\xD0\x85\xE1\xF8_K\x884\x0C\t\xC9\xD1\x91\xF9\xD4\xE9\x90a\x10\x1C\x90\x86\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA1PPPPPPV[`\x01T_\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82\x10\x15a\x10\x8AW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FEpoch is before relay genesis\0\0\0`D\x82\x01R`d\x01a\x04lV[`\x01Th\x01\0\0\0\0\0\0\0\0\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x82\x11\x15a\x11\x17W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FEpoch is not proven to the relay`D\x82\x01R\x7F yet\0\0\0\0\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\x04lV[_\x82\x81R`\x04` R`@\x90 Ta\x03\xA9\x90d\x01\0\0\0\0\x90\x04{\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x1B\x89V[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x11\xBAW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[a\x11\xC3_a\x1B\xB0V[V[_Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16a\x12.W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FRelay is not ready for use\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[_Tu\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x12\xAFW3_\x90\x81R`\x05` R`@\x90 T`\xFF\x16a\x12\xAFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x16`$\x82\x01R\x7FSubmitter unauthorized\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[_Ta\x12\xCD\x90`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02a\"\xAFV[a\x12\xD8\x90`Pa\"\xAFV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81Q\x14a\x131W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FInvalid header length\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[`\x01Th\x01\0\0\0\0\0\0\0\0\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16_\x90\x81R`\x04` R`@\x81 \x80T\x90\x91d\x01\0\0\0\0\x90\x91\x04{\xFF\xFF\xFF\xFF\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\x90\x80[_T`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x14:W_\x80a\x13\xB6\x87a\x13\xB0\x85`Pa#\x1FV[\x86a\x1A\x87V[\x91P\x91P\x84\x81\x14a\x14/W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FInvalid target in pre-retarget h`D\x82\x01R\x7Feaders\0\0\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\x04lV[P\x91P`\x01\x01a\x13\x85V[P_\x80Ta\x14{\x90a\x14_\x90`\x01\x90`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a#6V[a\x14j\x90`Pa\"\xAFV[\x86\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x1B^V[c\xFF\xFF\xFF\xFF\x16\x90PB\x81\x10a\x14\xD2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1E`$\x82\x01R\x7FEpoch cannot end in the future\0\0`D\x82\x01R`d\x01a\x04lV[\x83T_\x90a\x14\xE8\x90\x85\x90c\xFF\xFF\xFF\xFF\x16\x84a\x1C$V[_\x80T\x91\x92P\x90\x81\x90a\x15\"\x90a\x15\x11\x90`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`Pa\"\xAFV[\x89\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16a\x1B^V[_Tc\xFF\xFF\xFF\xFF\x91\x90\x91\x16\x91P`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16[_Ta\x15_\x90`\x01`\xB0\x1B\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x02a\"\xAFV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81\x10\x15a\x16eW_\x80a\x15\x81\x8Ba\x07\x90\x85`Pa#\x1FV[\x91P\x91P\x84_\x03a\x15\xE5W\x80\x94P\x80\x86\x16\x81\x14a\x15\xE0W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FInvalid target in new epoch\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[a\x16ZV[\x84\x81\x14a\x16ZW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FUnexpected target change after r`D\x82\x01R\x7Fetarget\0\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\x04lV[P\x95P`\x01\x01a\x15AV[P`\x01`\x08\x90T\x90a\x01\0\n\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01a\x16\x89\x91\x90a\"\xD9V[`\x01\x80Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x92\x83\x16h\x01\0\0\0\0\0\0\0\0\x90\x81\x02\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x92\x16\x91\x90\x91\x17\x91\x82\x90U`@\x80Q\x80\x82\x01\x82Rc\xFF\xFF\xFF\xFF\x80\x87\x16\x82R{\xFF\xFF\xFF\xFF\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\x89\x16` \x80\x85\x01\x91\x82R\x95\x90\x96\x04\x90\x96\x16_\x90\x81R`\x04\x90\x94R\x91\x83 \x90Q\x93Q\x90\x94\x16d\x01\0\0\0\0\x02\x92\x16\x91\x90\x91\x17\x90\x91U`\x02T\x90a\x17D\x84a\x1B\x89V[`\x03\x83\x90U`\x02\x81\x90U`@\x80Q\x84\x81R` \x81\x01\x83\x90R\x91\x92P\x7F\xA2\x82\xEEy\x8B\x13/\x9D\xC1\x1E\x06\xCDM\x8Ev~V+\xE8p\x96\x02\xCA\x14\xFE\xA7\xAB3\x92\xAC\xBD\xAB\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPPV[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x17\xFCW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16_\x81\x81R`\x05` \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`\x01\x17\x90U\x90Q\x91\x82R\x7F\xD56I\xB4\x92\xF78\xBBY\xD6\x82P\x99\xB5\x95Ps\xEF\xDA\x0B\xF9\xE3\xA7\xAD \xDA\"\xE1\x10\x12.)\x91\x01a\n\xE5V[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x18\xE0W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[_\x80T\x82\x15\x15u\x01\0\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\xFF\xFF\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x17\x90U`@Q\x7F\xD8\x13\xB2H\xD4\x9C\x8B\xF0\x8B\xE2\xB6\x94q&\xDAgc\xDF1\x0B\xEE\xD7\xBE\xA9wVElW'A\x9A\x90a\n\xE5\x90\x83\x15\x15\x81R` \x01\x90V[_Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x163\x14a\x19\xBFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x04lV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16a\x1AHW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01R\x7Fddress\0\0\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\x04lV[a\x1AQ\x81a\x1B\xB0V[PV[_a\x03\xA9a\x1Aa\x83a\x1C\xB6V[`\xD8\x81\x90\x1Cc\xFF\0\xFF\0\x16b\xFF\0\xFF`\xE8\x92\x90\x92\x1C\x91\x90\x91\x16\x17`\x10\x81\x81\x1B\x91\x90\x1C\x17\x90V[_\x80\x82\x15a\x1A\xE6Wa\x1A\x9A\x85\x85\x85a\x1C\xC2V[a\x1A\xE6W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01R\x7FInvalid chain\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[a\x1A\xF0\x85\x85a\x1C\xEBV[\x90Pa\x1A\xFE\x85\x85`Pa\x1D\x88V[\x91Pa\x1B\n\x82\x82a\x1D\xADV[a\x1BVW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x0C`$\x82\x01R\x7FInvalid work\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x04lV[\x93P\x93\x91PPV[_a\x1Bwa\x1Aaa\x1Bp\x84`Da#VV[\x85\x90a\x1F\x03V[\x93\x92PPPV[_a\x03\xA9\x82_a\x1C\xEBV[_a\x03\xA9{\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\x83a\x1F\x11V[_\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x81\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\x83\x16\x81\x17\x84U`@Q\x91\x90\x92\x16\x92\x83\x91\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x91\x90\xA3PPV[_\x80a\x1C0\x83\x85a\x1F\x1CV[\x90Pa\x1C@b\x12u\0`\x04a\x1F\x11V[\x81\x10\x15a\x1CXWa\x1CUb\x12u\0`\x04a\x1F\x11V[\x90P[a\x1Cfb\x12u\0`\x04a\x1FwV[\x81\x11\x15a\x1C~Wa\x1C{b\x12u\0`\x04a\x1FwV[\x90P[_a\x1C\x96\x82a\x1C\x90\x88b\x01\0\0a\x1F\x11V[\x90a\x1FwV[\x90Pa\x1C\xACb\x01\0\0a\x1C\x90\x83b\x12u\0a\x1F\x11V[\x96\x95PPPPPPV[_a\x03\xA9\x82`Da\x1F\x03V[_\x80a\x1C\xCE\x85\x85a\x1F\xEAV[\x90P\x82\x81\x14a\x1C\xE0W_\x91PPa\x1BwV[P`\x01\x94\x93PPPPV[_\x80a\x1C\xFBa\x1Bp\x84`Ha#VV[`\xE8\x1C\x90P_\x84a\x1D\r\x85`Ka#VV[\x81Q\x81\x10a\x1D\x1DWa\x1D\x1Da#iV[\x01` \x01Q`\xF8\x1C\x90P_a\x1DO\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a\x1Db`\x03\x84a#\x96V[`\xFF\x16\x90Pa\x1Ds\x81a\x01\0a$\x8AV[a\x1D}\x90\x83a#\x1FV[\x97\x96PPPPPPPV[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x82a\x1D\xBAWP_a\x03\xA9V[\x81a\x1E\xFB\x84_\x81\x90P`\x08\x81~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x90\x1B`\x08\x82\x90\x1C~\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\0\xFF\x16\x17\x90P`\x10\x81}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x90\x1B`\x10\x82\x90\x1C}\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\0\0\xFF\xFF\x16\x17\x90P` \x81{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x90\x1B` \x82\x90\x1C{\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\0\0\0\0\xFF\xFF\xFF\xFF\x16\x17\x90P`@\x81w\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90\x1B`@\x82\x90\x1Cw\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x17\x90P`\x80\x81\x90\x1B`\x80\x82\x90\x1C\x17\x90P\x91\x90PV[\x10\x93\x92PPPV[_a\x1Bw\x83\x83\x01` \x01Q\x90V[_a\x1Bw\x82\x84a\"\x9CV[_\x82\x82\x11\x15a\x1FmW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FUnderflow during subtraction.\0\0\0`D\x82\x01R`d\x01a\x04lV[a\x1Bw\x82\x84a#\x0CV[_\x82_\x03a\x1F\x86WP_a\x03\xA9V[a\x1F\x90\x82\x84a#\x1FV[\x90P\x81a\x1F\x9D\x84\x83a\"\x9CV[\x14a\x03\xA9W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FOverflow during multiplication.\0`D\x82\x01R`d\x01a\x04lV[_a\x1Bwa\x1F\xF9\x83`\x04a#VV[\x84\x01` \x01Q\x90V[_` \x82\x84\x03\x12\x15a \x12W__\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_R`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a VW__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a lW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a |W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a \x96Wa \x96a \x19V[`@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!\x02Wa!\x02a \x19V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a!\x19W__\xFD[\x81` \x84\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a!MW__\xFD[\x91\x90PV[_` \x82\x84\x03\x12\x15a!bW__\xFD[a\x1Bw\x82a!6V[_` \x82\x84\x03\x12\x15a!{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\x14a\x1BwW__\xFD[____``\x85\x87\x03\x12\x15a!\xB1W__\xFD[\x845g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a!\xC7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a!\xD7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a!\xEDW__\xFD[\x87` \x82\x84\x01\x01\x11\x15a!\xFEW__\xFD[` \x91\x82\x01\x95P\x93P\x85\x015\x91Pa\"\x18`@\x86\x01a!6V[\x90P\x92\x95\x91\x94P\x92PV[_` \x82\x84\x03\x12\x15a\"3W__\xFD[\x815\x80\x15\x15\x81\x14a\x1BwW__\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`\x12`\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`\x11`\x04R`$_\xFD[_\x82a\"\xAAWa\"\xAAa\"BV[P\x04\x90V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x02\x90\x81\x16\x90\x81\x81\x14a\"\xD2Wa\"\xD2a\"oV[P\x92\x91PPV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x03\xA9Wa\x03\xA9a\"oV[_\x82a#\x07Wa#\x07a\"BV[P\x06\x90V[\x81\x81\x03\x81\x81\x11\x15a\x03\xA9Wa\x03\xA9a\"oV[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x03\xA9Wa\x03\xA9a\"oV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x03\xA9Wa\x03\xA9a\"oV[\x80\x82\x01\x80\x82\x11\x15a\x03\xA9Wa\x03\xA9a\"oV[\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[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x03\xA9Wa\x03\xA9a\"oV[`\x01\x81[`\x01\x84\x11\x15a\x1BVW\x80\x85\x04\x81\x11\x15a#\xCEWa#\xCEa\"oV[`\x01\x84\x16\x15a#\xDCW\x90\x81\x02\x90[`\x01\x93\x90\x93\x1C\x92\x80\x02a#\xB3V[_\x82a#\xF8WP`\x01a\x03\xA9V[\x81a$\x04WP_a\x03\xA9V[\x81`\x01\x81\x14a$\x1AW`\x02\x81\x14a$$Wa$@V[`\x01\x91PPa\x03\xA9V[`\xFF\x84\x11\x15a$5Wa$5a\"oV[PP`\x01\x82\x1Ba\x03\xA9V[P` \x83\x10a\x013\x83\x10\x16`N\x84\x10`\x0B\x84\x10\x16\x17\x15a$cWP\x81\x81\na\x03\xA9V[a$o_\x19\x84\x84a#\xAFV[\x80_\x19\x04\x82\x11\x15a$\x82Wa$\x82a\"oV[\x02\x93\x92PPPV[_a\x1Bw\x83\x83a#\xEAV\xFE\xA2dipfsX\"\x12 e\x7F\xB9\xDBv0*\xD1\x86\x12>\xAC\x9B\xAC\xE1Wv\x19\xC6t~j\xB9z\x11q\x9FYF\r\x92^dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `AuthorizationRequirementChanged(bool)` and selector `0xd813b248d49c8bf08be2b6947126da6763df310beed7bea97756456c5727419a`. -```solidity -event AuthorizationRequirementChanged(bool newStatus); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct AuthorizationRequirementChanged { - #[allow(missing_docs)] - pub newStatus: bool, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for AuthorizationRequirementChanged { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "AuthorizationRequirementChanged(bool)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 216u8, 19u8, 178u8, 72u8, 212u8, 156u8, 139u8, 240u8, 139u8, 226u8, - 182u8, 148u8, 113u8, 38u8, 218u8, 103u8, 99u8, 223u8, 49u8, 11u8, 238u8, - 215u8, 190u8, 169u8, 119u8, 86u8, 69u8, 108u8, 87u8, 39u8, 65u8, 154u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { newStatus: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.newStatus, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 AuthorizationRequirementChanged { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&AuthorizationRequirementChanged> - for alloy_sol_types::private::LogData { - #[inline] - fn from( - this: &AuthorizationRequirementChanged, - ) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `Genesis(uint256)` and selector `0x2381d16925551c2fb1a5edfcf4fce2f6d085e1f85f4b88340c09c9d191f9d4e9`. -```solidity -event Genesis(uint256 blockHeight); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct Genesis { - #[allow(missing_docs)] - pub blockHeight: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for Genesis { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "Genesis(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 129u8, 209u8, 105u8, 37u8, 85u8, 28u8, 47u8, 177u8, 165u8, 237u8, - 252u8, 244u8, 252u8, 226u8, 246u8, 208u8, 133u8, 225u8, 248u8, 95u8, - 75u8, 136u8, 52u8, 12u8, 9u8, 201u8, 209u8, 145u8, 249u8, 212u8, 233u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { blockHeight: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.blockHeight), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 Genesis { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&Genesis> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &Genesis) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for OwnershipTransferred { - type DataTuple<'a> = (); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - 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, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - previousOwner: topics.1, - newOwner: topics.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return 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) -> ::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() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = ::encode_topic( - &self.previousOwner, - ); - out[2usize] = ::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(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `ProofLengthChanged(uint256)` and selector `0x3e9f904d8cf11753c79b67c8259c582056d4a7d8af120f81257a59eeb8824b96`. -```solidity -event ProofLengthChanged(uint256 newLength); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct ProofLengthChanged { - #[allow(missing_docs)] - pub newLength: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for ProofLengthChanged { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "ProofLengthChanged(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 62u8, 159u8, 144u8, 77u8, 140u8, 241u8, 23u8, 83u8, 199u8, 155u8, 103u8, - 200u8, 37u8, 156u8, 88u8, 32u8, 86u8, 212u8, 167u8, 216u8, 175u8, 18u8, - 15u8, 129u8, 37u8, 122u8, 89u8, 238u8, 184u8, 130u8, 75u8, 150u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { newLength: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.newLength), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 ProofLengthChanged { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&ProofLengthChanged> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &ProofLengthChanged) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `Retarget(uint256,uint256)` and selector `0xa282ee798b132f9dc11e06cd4d8e767e562be8709602ca14fea7ab3392acbdab`. -```solidity -event Retarget(uint256 oldDifficulty, uint256 newDifficulty); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct Retarget { - #[allow(missing_docs)] - pub oldDifficulty: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub newDifficulty: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for Retarget { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "Retarget(uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 162u8, 130u8, 238u8, 121u8, 139u8, 19u8, 47u8, 157u8, 193u8, 30u8, 6u8, - 205u8, 77u8, 142u8, 118u8, 126u8, 86u8, 43u8, 232u8, 112u8, 150u8, 2u8, - 202u8, 20u8, 254u8, 167u8, 171u8, 51u8, 146u8, 172u8, 189u8, 171u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - oldDifficulty: data.0, - newDifficulty: data.1, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.oldDifficulty), - as alloy_sol_types::SolType>::tokenize(&self.newDifficulty), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 Retarget { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&Retarget> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &Retarget) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `SubmitterAuthorized(address)` and selector `0xd53649b492f738bb59d6825099b5955073efda0bf9e3a7ad20da22e110122e29`. -```solidity -event SubmitterAuthorized(address submitter); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct SubmitterAuthorized { - #[allow(missing_docs)] - pub submitter: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for SubmitterAuthorized { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "SubmitterAuthorized(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 213u8, 54u8, 73u8, 180u8, 146u8, 247u8, 56u8, 187u8, 89u8, 214u8, 130u8, - 80u8, 153u8, 181u8, 149u8, 80u8, 115u8, 239u8, 218u8, 11u8, 249u8, 227u8, - 167u8, 173u8, 32u8, 218u8, 34u8, 225u8, 16u8, 18u8, 46u8, 41u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { submitter: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.submitter, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 SubmitterAuthorized { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&SubmitterAuthorized> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &SubmitterAuthorized) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `SubmitterDeauthorized(address)` and selector `0x7498b96beeabea5ad3139f1a2861a03e480034254e36b10aae2e6e42ad7b4b68`. -```solidity -event SubmitterDeauthorized(address submitter); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct SubmitterDeauthorized { - #[allow(missing_docs)] - pub submitter: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for SubmitterDeauthorized { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "SubmitterDeauthorized(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 116u8, 152u8, 185u8, 107u8, 238u8, 171u8, 234u8, 90u8, 211u8, 19u8, - 159u8, 26u8, 40u8, 97u8, 160u8, 62u8, 72u8, 0u8, 52u8, 37u8, 78u8, 54u8, - 177u8, 10u8, 174u8, 46u8, 110u8, 66u8, 173u8, 123u8, 75u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { submitter: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.submitter, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 SubmitterDeauthorized { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&SubmitterDeauthorized> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &SubmitterDeauthorized) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `authorizationRequired()` and selector `0x95410d2b`. -```solidity -function authorizationRequired() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct authorizationRequiredCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`authorizationRequired()`](authorizationRequiredCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct authorizationRequiredReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: authorizationRequiredCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for authorizationRequiredCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: authorizationRequiredReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for authorizationRequiredReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for authorizationRequiredCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "authorizationRequired()"; - const SELECTOR: [u8; 4] = [149u8, 65u8, 13u8, 43u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: authorizationRequiredReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: authorizationRequiredReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `authorize(address)` and selector `0xb6a5d7de`. -```solidity -function authorize(address submitter) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct authorizeCall { - #[allow(missing_docs)] - pub submitter: alloy::sol_types::private::Address, - } - ///Container type for the return parameters of the [`authorize(address)`](authorizeCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct authorizeReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: authorizeCall) -> Self { - (value.submitter,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for authorizeCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { submitter: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: authorizeReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for authorizeReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl authorizeReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for authorizeCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = authorizeReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "authorize(address)"; - const SELECTOR: [u8; 4] = [182u8, 165u8, 215u8, 222u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.submitter, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - authorizeReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `currentEpoch()` and selector `0x76671808`. -```solidity -function currentEpoch() external view returns (uint64); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct currentEpochCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`currentEpoch()`](currentEpochCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct currentEpochReturn { - #[allow(missing_docs)] - pub _0: u64, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: currentEpochCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for currentEpochCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (u64,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: currentEpochReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for currentEpochReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for currentEpochCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = u64; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "currentEpoch()"; - const SELECTOR: [u8; 4] = [118u8, 103u8, 24u8, 8u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: currentEpochReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: currentEpochReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `deauthorize(address)` and selector `0x27c97fa5`. -```solidity -function deauthorize(address submitter) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct deauthorizeCall { - #[allow(missing_docs)] - pub submitter: alloy::sol_types::private::Address, - } - ///Container type for the return parameters of the [`deauthorize(address)`](deauthorizeCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct deauthorizeReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: deauthorizeCall) -> Self { - (value.submitter,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for deauthorizeCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { submitter: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: deauthorizeReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for deauthorizeReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl deauthorizeReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for deauthorizeCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = deauthorizeReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "deauthorize(address)"; - const SELECTOR: [u8; 4] = [39u8, 201u8, 127u8, 165u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.submitter, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - deauthorizeReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `genesis(bytes,uint256,uint64)` and selector `0x4ca49f51`. -```solidity -function genesis(bytes memory genesisHeader, uint256 genesisHeight, uint64 genesisProofLength) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct genesisCall { - #[allow(missing_docs)] - pub genesisHeader: alloy::sol_types::private::Bytes, - #[allow(missing_docs)] - pub genesisHeight: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub genesisProofLength: u64, - } - ///Container type for the return parameters of the [`genesis(bytes,uint256,uint64)`](genesisCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct genesisReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Bytes, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<64>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Bytes, - alloy::sol_types::private::primitives::aliases::U256, - u64, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: genesisCall) -> Self { - (value.genesisHeader, value.genesisHeight, value.genesisProofLength) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for genesisCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - genesisHeader: tuple.0, - genesisHeight: tuple.1, - genesisProofLength: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: genesisReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for genesisReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl genesisReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for genesisCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Bytes, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<64>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = genesisReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "genesis(bytes,uint256,uint64)"; - const SELECTOR: [u8; 4] = [76u8, 164u8, 159u8, 81u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.genesisHeader, - ), - as alloy_sol_types::SolType>::tokenize(&self.genesisHeight), - as alloy_sol_types::SolType>::tokenize(&self.genesisProofLength), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - genesisReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `genesisEpoch()` and selector `0xb70e6be6`. -```solidity -function genesisEpoch() external view returns (uint64); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct genesisEpochCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`genesisEpoch()`](genesisEpochCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct genesisEpochReturn { - #[allow(missing_docs)] - pub _0: u64, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: genesisEpochCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for genesisEpochCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (u64,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: genesisEpochReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for genesisEpochReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for genesisEpochCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = u64; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "genesisEpoch()"; - const SELECTOR: [u8; 4] = [183u8, 14u8, 107u8, 230u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: genesisEpochReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: genesisEpochReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getBlockDifficulty(uint256)` and selector `0x06a27422`. -```solidity -function getBlockDifficulty(uint256 blockNumber) external view returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getBlockDifficultyCall { - #[allow(missing_docs)] - pub blockNumber: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getBlockDifficulty(uint256)`](getBlockDifficultyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getBlockDifficultyReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getBlockDifficultyCall) -> Self { - (value.blockNumber,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getBlockDifficultyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { blockNumber: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getBlockDifficultyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getBlockDifficultyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getBlockDifficultyCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getBlockDifficulty(uint256)"; - const SELECTOR: [u8; 4] = [6u8, 162u8, 116u8, 34u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.blockNumber), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getBlockDifficultyReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getBlockDifficultyReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getCurrentAndPrevEpochDifficulty()` and selector `0x3a1b77b0`. -```solidity -function getCurrentAndPrevEpochDifficulty() external view returns (uint256 current, uint256 previous); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getCurrentAndPrevEpochDifficultyCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getCurrentAndPrevEpochDifficulty()`](getCurrentAndPrevEpochDifficultyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getCurrentAndPrevEpochDifficultyReturn { - #[allow(missing_docs)] - pub current: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub previous: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getCurrentAndPrevEpochDifficultyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getCurrentAndPrevEpochDifficultyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getCurrentAndPrevEpochDifficultyReturn) -> Self { - (value.current, value.previous) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getCurrentAndPrevEpochDifficultyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - current: tuple.0, - previous: tuple.1, - } - } - } - } - impl getCurrentAndPrevEpochDifficultyReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - ( - as alloy_sol_types::SolType>::tokenize(&self.current), - as alloy_sol_types::SolType>::tokenize(&self.previous), - ) - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getCurrentAndPrevEpochDifficultyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = getCurrentAndPrevEpochDifficultyReturn; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getCurrentAndPrevEpochDifficulty()"; - const SELECTOR: [u8; 4] = [58u8, 27u8, 119u8, 176u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - getCurrentAndPrevEpochDifficultyReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getCurrentEpochDifficulty()` and selector `0x113764be`. -```solidity -function getCurrentEpochDifficulty() external view returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getCurrentEpochDifficultyCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getCurrentEpochDifficulty()`](getCurrentEpochDifficultyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getCurrentEpochDifficultyReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getCurrentEpochDifficultyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getCurrentEpochDifficultyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getCurrentEpochDifficultyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getCurrentEpochDifficultyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getCurrentEpochDifficultyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getCurrentEpochDifficulty()"; - const SELECTOR: [u8; 4] = [17u8, 55u8, 100u8, 190u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getCurrentEpochDifficultyReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getCurrentEpochDifficultyReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getEpochDifficulty(uint256)` and selector `0x620414e6`. -```solidity -function getEpochDifficulty(uint256 epochNumber) external view returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getEpochDifficultyCall { - #[allow(missing_docs)] - pub epochNumber: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getEpochDifficulty(uint256)`](getEpochDifficultyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getEpochDifficultyReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getEpochDifficultyCall) -> Self { - (value.epochNumber,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getEpochDifficultyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { epochNumber: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getEpochDifficultyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getEpochDifficultyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getEpochDifficultyCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getEpochDifficulty(uint256)"; - const SELECTOR: [u8; 4] = [98u8, 4u8, 20u8, 230u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.epochNumber), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getEpochDifficultyReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getEpochDifficultyReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getPrevEpochDifficulty()` and selector `0x2b97be24`. -```solidity -function getPrevEpochDifficulty() external view returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getPrevEpochDifficultyCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getPrevEpochDifficulty()`](getPrevEpochDifficultyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getPrevEpochDifficultyReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getPrevEpochDifficultyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getPrevEpochDifficultyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getPrevEpochDifficultyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getPrevEpochDifficultyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getPrevEpochDifficultyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getPrevEpochDifficulty()"; - const SELECTOR: [u8; 4] = [43u8, 151u8, 190u8, 36u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getPrevEpochDifficultyReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getPrevEpochDifficultyReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getRelayRange()` and selector `0x10b76ed8`. -```solidity -function getRelayRange() external view returns (uint256 relayGenesis, uint256 currentEpochEnd); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getRelayRangeCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getRelayRange()`](getRelayRangeCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getRelayRangeReturn { - #[allow(missing_docs)] - pub relayGenesis: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub currentEpochEnd: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getRelayRangeCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getRelayRangeCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getRelayRangeReturn) -> Self { - (value.relayGenesis, value.currentEpochEnd) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getRelayRangeReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - relayGenesis: tuple.0, - currentEpochEnd: tuple.1, - } - } - } - } - impl getRelayRangeReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.relayGenesis), - as alloy_sol_types::SolType>::tokenize(&self.currentEpochEnd), - ) - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getRelayRangeCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = getRelayRangeReturn; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getRelayRange()"; - const SELECTOR: [u8; 4] = [16u8, 183u8, 110u8, 216u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - getRelayRangeReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `isAuthorized(address)` and selector `0xfe9fbb80`. -```solidity -function isAuthorized(address) external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct isAuthorizedCall(pub alloy::sol_types::private::Address); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`isAuthorized(address)`](isAuthorizedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct isAuthorizedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: isAuthorizedCall) -> Self { - (value.0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for isAuthorizedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self(tuple.0) - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: isAuthorizedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for isAuthorizedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for isAuthorizedCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "isAuthorized(address)"; - const SELECTOR: [u8; 4] = [254u8, 159u8, 187u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.0, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: isAuthorizedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: isAuthorizedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: ownerCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for ownerCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: ownerReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for ownerReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for ownerCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "owner()"; - const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: ownerReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `proofLength()` and selector `0xf5619fda`. -```solidity -function proofLength() external view returns (uint64); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct proofLengthCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`proofLength()`](proofLengthCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct proofLengthReturn { - #[allow(missing_docs)] - pub _0: u64, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: proofLengthCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for proofLengthCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (u64,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: proofLengthReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for proofLengthReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for proofLengthCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = u64; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "proofLength()"; - const SELECTOR: [u8; 4] = [245u8, 97u8, 159u8, 218u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: proofLengthReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: proofLengthReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `ready()` and selector `0x6defbf80`. -```solidity -function ready() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct readyCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`ready()`](readyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct readyReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: readyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for readyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: readyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for readyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for readyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "ready()"; - const SELECTOR: [u8; 4] = [109u8, 239u8, 191u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: readyReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: readyReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: renounceOwnershipCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for renounceOwnershipCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: renounceOwnershipReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for renounceOwnershipReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl renounceOwnershipReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for renounceOwnershipCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = renounceOwnershipReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "renounceOwnership()"; - const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8]; - #[inline] - fn new<'a>( - tuple: 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 { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `retarget(bytes)` and selector `0x7ca5b1dd`. -```solidity -function retarget(bytes memory headers) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct retargetCall { - #[allow(missing_docs)] - pub headers: alloy::sol_types::private::Bytes, - } - ///Container type for the return parameters of the [`retarget(bytes)`](retargetCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct retargetReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: retargetCall) -> Self { - (value.headers,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for retargetCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { headers: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: retargetReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for retargetReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl retargetReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for retargetCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Bytes,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = retargetReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "retarget(bytes)"; - const SELECTOR: [u8; 4] = [124u8, 165u8, 177u8, 221u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.headers, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - retargetReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `setAuthorizationStatus(bool)` and selector `0xeb8695ef`. -```solidity -function setAuthorizationStatus(bool status) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setAuthorizationStatusCall { - #[allow(missing_docs)] - pub status: bool, - } - ///Container type for the return parameters of the [`setAuthorizationStatus(bool)`](setAuthorizationStatusCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setAuthorizationStatusReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: setAuthorizationStatusCall) -> Self { - (value.status,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for setAuthorizationStatusCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { status: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: setAuthorizationStatusReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for setAuthorizationStatusReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl setAuthorizationStatusReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for setAuthorizationStatusCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Bool,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = setAuthorizationStatusReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "setAuthorizationStatus(bool)"; - const SELECTOR: [u8; 4] = [235u8, 134u8, 149u8, 239u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.status, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - setAuthorizationStatusReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `setProofLength(uint64)` and selector `0x19c9aa32`. -```solidity -function setProofLength(uint64 newLength) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setProofLengthCall { - #[allow(missing_docs)] - pub newLength: u64, - } - ///Container type for the return parameters of the [`setProofLength(uint64)`](setProofLengthCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setProofLengthReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (u64,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setProofLengthCall) -> Self { - (value.newLength,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setProofLengthCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { newLength: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: setProofLengthReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for setProofLengthReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl setProofLengthReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for setProofLengthCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<64>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = setProofLengthReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "setProofLength(uint64)"; - const SELECTOR: [u8; 4] = [25u8, 201u8, 170u8, 50u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.newLength), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - setProofLengthReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: transferOwnershipCall) -> Self { - (value.newOwner,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for transferOwnershipCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { newOwner: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: transferOwnershipReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for transferOwnershipReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl transferOwnershipReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for transferOwnershipCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = transferOwnershipReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "transferOwnership(address)"; - const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::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 { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `validateChain(bytes)` and selector `0x189179a3`. -```solidity -function validateChain(bytes memory headers) external view returns (uint256 startingHeaderTimestamp, uint256 headerCount); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct validateChainCall { - #[allow(missing_docs)] - pub headers: alloy::sol_types::private::Bytes, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`validateChain(bytes)`](validateChainCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct validateChainReturn { - #[allow(missing_docs)] - pub startingHeaderTimestamp: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub headerCount: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: validateChainCall) -> Self { - (value.headers,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for validateChainCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { headers: tuple.0 } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: validateChainReturn) -> Self { - (value.startingHeaderTimestamp, value.headerCount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for validateChainReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - startingHeaderTimestamp: tuple.0, - headerCount: tuple.1, - } - } - } - } - impl validateChainReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize( - &self.startingHeaderTimestamp, - ), - as alloy_sol_types::SolType>::tokenize(&self.headerCount), - ) - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for validateChainCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Bytes,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = validateChainReturn; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "validateChain(bytes)"; - const SELECTOR: [u8; 4] = [24u8, 145u8, 121u8, 163u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.headers, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - validateChainReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`LightRelay`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum LightRelayCalls { - #[allow(missing_docs)] - authorizationRequired(authorizationRequiredCall), - #[allow(missing_docs)] - authorize(authorizeCall), - #[allow(missing_docs)] - currentEpoch(currentEpochCall), - #[allow(missing_docs)] - deauthorize(deauthorizeCall), - #[allow(missing_docs)] - genesis(genesisCall), - #[allow(missing_docs)] - genesisEpoch(genesisEpochCall), - #[allow(missing_docs)] - getBlockDifficulty(getBlockDifficultyCall), - #[allow(missing_docs)] - getCurrentAndPrevEpochDifficulty(getCurrentAndPrevEpochDifficultyCall), - #[allow(missing_docs)] - getCurrentEpochDifficulty(getCurrentEpochDifficultyCall), - #[allow(missing_docs)] - getEpochDifficulty(getEpochDifficultyCall), - #[allow(missing_docs)] - getPrevEpochDifficulty(getPrevEpochDifficultyCall), - #[allow(missing_docs)] - getRelayRange(getRelayRangeCall), - #[allow(missing_docs)] - isAuthorized(isAuthorizedCall), - #[allow(missing_docs)] - owner(ownerCall), - #[allow(missing_docs)] - proofLength(proofLengthCall), - #[allow(missing_docs)] - ready(readyCall), - #[allow(missing_docs)] - renounceOwnership(renounceOwnershipCall), - #[allow(missing_docs)] - retarget(retargetCall), - #[allow(missing_docs)] - setAuthorizationStatus(setAuthorizationStatusCall), - #[allow(missing_docs)] - setProofLength(setProofLengthCall), - #[allow(missing_docs)] - transferOwnership(transferOwnershipCall), - #[allow(missing_docs)] - validateChain(validateChainCall), - } - #[automatically_derived] - impl LightRelayCalls { - /// 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, 162u8, 116u8, 34u8], - [16u8, 183u8, 110u8, 216u8], - [17u8, 55u8, 100u8, 190u8], - [24u8, 145u8, 121u8, 163u8], - [25u8, 201u8, 170u8, 50u8], - [39u8, 201u8, 127u8, 165u8], - [43u8, 151u8, 190u8, 36u8], - [58u8, 27u8, 119u8, 176u8], - [76u8, 164u8, 159u8, 81u8], - [98u8, 4u8, 20u8, 230u8], - [109u8, 239u8, 191u8, 128u8], - [113u8, 80u8, 24u8, 166u8], - [118u8, 103u8, 24u8, 8u8], - [124u8, 165u8, 177u8, 221u8], - [141u8, 165u8, 203u8, 91u8], - [149u8, 65u8, 13u8, 43u8], - [182u8, 165u8, 215u8, 222u8], - [183u8, 14u8, 107u8, 230u8], - [235u8, 134u8, 149u8, 239u8], - [242u8, 253u8, 227u8, 139u8], - [245u8, 97u8, 159u8, 218u8], - [254u8, 159u8, 187u8, 128u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for LightRelayCalls { - const NAME: &'static str = "LightRelayCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 22usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::authorizationRequired(_) => { - ::SELECTOR - } - Self::authorize(_) => { - ::SELECTOR - } - Self::currentEpoch(_) => { - ::SELECTOR - } - Self::deauthorize(_) => { - ::SELECTOR - } - Self::genesis(_) => ::SELECTOR, - Self::genesisEpoch(_) => { - ::SELECTOR - } - Self::getBlockDifficulty(_) => { - ::SELECTOR - } - Self::getCurrentAndPrevEpochDifficulty(_) => { - ::SELECTOR - } - Self::getCurrentEpochDifficulty(_) => { - ::SELECTOR - } - Self::getEpochDifficulty(_) => { - ::SELECTOR - } - Self::getPrevEpochDifficulty(_) => { - ::SELECTOR - } - Self::getRelayRange(_) => { - ::SELECTOR - } - Self::isAuthorized(_) => { - ::SELECTOR - } - Self::owner(_) => ::SELECTOR, - Self::proofLength(_) => { - ::SELECTOR - } - Self::ready(_) => ::SELECTOR, - Self::renounceOwnership(_) => { - ::SELECTOR - } - Self::retarget(_) => ::SELECTOR, - Self::setAuthorizationStatus(_) => { - ::SELECTOR - } - Self::setProofLength(_) => { - ::SELECTOR - } - Self::transferOwnership(_) => { - ::SELECTOR - } - Self::validateChain(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getBlockDifficulty( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(LightRelayCalls::getBlockDifficulty) - } - getBlockDifficulty - }, - { - fn getRelayRange( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(LightRelayCalls::getRelayRange) - } - getRelayRange - }, - { - fn getCurrentEpochDifficulty( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(LightRelayCalls::getCurrentEpochDifficulty) - } - getCurrentEpochDifficulty - }, - { - fn validateChain( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(LightRelayCalls::validateChain) - } - validateChain - }, - { - fn setProofLength( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(LightRelayCalls::setProofLength) - } - setProofLength - }, - { - fn deauthorize( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(LightRelayCalls::deauthorize) - } - deauthorize - }, - { - fn getPrevEpochDifficulty( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(LightRelayCalls::getPrevEpochDifficulty) - } - getPrevEpochDifficulty - }, - { - fn getCurrentAndPrevEpochDifficulty( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(LightRelayCalls::getCurrentAndPrevEpochDifficulty) - } - getCurrentAndPrevEpochDifficulty - }, - { - fn genesis(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(LightRelayCalls::genesis) - } - genesis - }, - { - fn getEpochDifficulty( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(LightRelayCalls::getEpochDifficulty) - } - getEpochDifficulty - }, - { - fn ready(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(LightRelayCalls::ready) - } - ready - }, - { - fn renounceOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(LightRelayCalls::renounceOwnership) - } - renounceOwnership - }, - { - fn currentEpoch( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(LightRelayCalls::currentEpoch) - } - currentEpoch - }, - { - fn retarget( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(LightRelayCalls::retarget) - } - retarget - }, - { - fn owner(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(LightRelayCalls::owner) - } - owner - }, - { - fn authorizationRequired( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(LightRelayCalls::authorizationRequired) - } - authorizationRequired - }, - { - fn authorize( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(LightRelayCalls::authorize) - } - authorize - }, - { - fn genesisEpoch( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(LightRelayCalls::genesisEpoch) - } - genesisEpoch - }, - { - fn setAuthorizationStatus( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(LightRelayCalls::setAuthorizationStatus) - } - setAuthorizationStatus - }, - { - fn transferOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(LightRelayCalls::transferOwnership) - } - transferOwnership - }, - { - fn proofLength( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(LightRelayCalls::proofLength) - } - proofLength - }, - { - fn isAuthorized( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(LightRelayCalls::isAuthorized) - } - isAuthorized - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getBlockDifficulty( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(LightRelayCalls::getBlockDifficulty) - } - getBlockDifficulty - }, - { - fn getRelayRange( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(LightRelayCalls::getRelayRange) - } - getRelayRange - }, - { - fn getCurrentEpochDifficulty( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(LightRelayCalls::getCurrentEpochDifficulty) - } - getCurrentEpochDifficulty - }, - { - fn validateChain( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(LightRelayCalls::validateChain) - } - validateChain - }, - { - fn setProofLength( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(LightRelayCalls::setProofLength) - } - setProofLength - }, - { - fn deauthorize( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(LightRelayCalls::deauthorize) - } - deauthorize - }, - { - fn getPrevEpochDifficulty( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(LightRelayCalls::getPrevEpochDifficulty) - } - getPrevEpochDifficulty - }, - { - fn getCurrentAndPrevEpochDifficulty( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(LightRelayCalls::getCurrentAndPrevEpochDifficulty) - } - getCurrentAndPrevEpochDifficulty - }, - { - fn genesis(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(LightRelayCalls::genesis) - } - genesis - }, - { - fn getEpochDifficulty( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(LightRelayCalls::getEpochDifficulty) - } - getEpochDifficulty - }, - { - fn ready(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(LightRelayCalls::ready) - } - ready - }, - { - fn renounceOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(LightRelayCalls::renounceOwnership) - } - renounceOwnership - }, - { - fn currentEpoch( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(LightRelayCalls::currentEpoch) - } - currentEpoch - }, - { - fn retarget( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(LightRelayCalls::retarget) - } - retarget - }, - { - fn owner(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(LightRelayCalls::owner) - } - owner - }, - { - fn authorizationRequired( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(LightRelayCalls::authorizationRequired) - } - authorizationRequired - }, - { - fn authorize( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(LightRelayCalls::authorize) - } - authorize - }, - { - fn genesisEpoch( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(LightRelayCalls::genesisEpoch) - } - genesisEpoch - }, - { - fn setAuthorizationStatus( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(LightRelayCalls::setAuthorizationStatus) - } - setAuthorizationStatus - }, - { - fn transferOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(LightRelayCalls::transferOwnership) - } - transferOwnership - }, - { - fn proofLength( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(LightRelayCalls::proofLength) - } - proofLength - }, - { - fn isAuthorized( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(LightRelayCalls::isAuthorized) - } - isAuthorized - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::authorizationRequired(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::authorize(inner) => { - ::abi_encoded_size(inner) - } - Self::currentEpoch(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::deauthorize(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::genesis(inner) => { - ::abi_encoded_size(inner) - } - Self::genesisEpoch(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getBlockDifficulty(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getCurrentAndPrevEpochDifficulty(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getCurrentEpochDifficulty(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getEpochDifficulty(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getPrevEpochDifficulty(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getRelayRange(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::isAuthorized(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::owner(inner) => { - ::abi_encoded_size(inner) - } - Self::proofLength(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::ready(inner) => { - ::abi_encoded_size(inner) - } - Self::renounceOwnership(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::retarget(inner) => { - ::abi_encoded_size(inner) - } - Self::setAuthorizationStatus(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::setProofLength(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::transferOwnership(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::validateChain(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::authorizationRequired(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::authorize(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::currentEpoch(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::deauthorize(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::genesis(inner) => { - ::abi_encode_raw(inner, out) - } - Self::genesisEpoch(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getBlockDifficulty(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getCurrentAndPrevEpochDifficulty(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getCurrentEpochDifficulty(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getEpochDifficulty(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getPrevEpochDifficulty(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getRelayRange(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::isAuthorized(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::owner(inner) => { - ::abi_encode_raw(inner, out) - } - Self::proofLength(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::ready(inner) => { - ::abi_encode_raw(inner, out) - } - Self::renounceOwnership(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::retarget(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::setAuthorizationStatus(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::setProofLength(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::transferOwnership(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::validateChain(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`LightRelay`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum LightRelayEvents { - #[allow(missing_docs)] - AuthorizationRequirementChanged(AuthorizationRequirementChanged), - #[allow(missing_docs)] - Genesis(Genesis), - #[allow(missing_docs)] - OwnershipTransferred(OwnershipTransferred), - #[allow(missing_docs)] - ProofLengthChanged(ProofLengthChanged), - #[allow(missing_docs)] - Retarget(Retarget), - #[allow(missing_docs)] - SubmitterAuthorized(SubmitterAuthorized), - #[allow(missing_docs)] - SubmitterDeauthorized(SubmitterDeauthorized), - } - #[automatically_derived] - impl LightRelayEvents { - /// 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]] = &[ - [ - 35u8, 129u8, 209u8, 105u8, 37u8, 85u8, 28u8, 47u8, 177u8, 165u8, 237u8, - 252u8, 244u8, 252u8, 226u8, 246u8, 208u8, 133u8, 225u8, 248u8, 95u8, - 75u8, 136u8, 52u8, 12u8, 9u8, 201u8, 209u8, 145u8, 249u8, 212u8, 233u8, - ], - [ - 62u8, 159u8, 144u8, 77u8, 140u8, 241u8, 23u8, 83u8, 199u8, 155u8, 103u8, - 200u8, 37u8, 156u8, 88u8, 32u8, 86u8, 212u8, 167u8, 216u8, 175u8, 18u8, - 15u8, 129u8, 37u8, 122u8, 89u8, 238u8, 184u8, 130u8, 75u8, 150u8, - ], - [ - 116u8, 152u8, 185u8, 107u8, 238u8, 171u8, 234u8, 90u8, 211u8, 19u8, - 159u8, 26u8, 40u8, 97u8, 160u8, 62u8, 72u8, 0u8, 52u8, 37u8, 78u8, 54u8, - 177u8, 10u8, 174u8, 46u8, 110u8, 66u8, 173u8, 123u8, 75u8, 104u8, - ], - [ - 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, - ], - [ - 162u8, 130u8, 238u8, 121u8, 139u8, 19u8, 47u8, 157u8, 193u8, 30u8, 6u8, - 205u8, 77u8, 142u8, 118u8, 126u8, 86u8, 43u8, 232u8, 112u8, 150u8, 2u8, - 202u8, 20u8, 254u8, 167u8, 171u8, 51u8, 146u8, 172u8, 189u8, 171u8, - ], - [ - 213u8, 54u8, 73u8, 180u8, 146u8, 247u8, 56u8, 187u8, 89u8, 214u8, 130u8, - 80u8, 153u8, 181u8, 149u8, 80u8, 115u8, 239u8, 218u8, 11u8, 249u8, 227u8, - 167u8, 173u8, 32u8, 218u8, 34u8, 225u8, 16u8, 18u8, 46u8, 41u8, - ], - [ - 216u8, 19u8, 178u8, 72u8, 212u8, 156u8, 139u8, 240u8, 139u8, 226u8, - 182u8, 148u8, 113u8, 38u8, 218u8, 103u8, 99u8, 223u8, 49u8, 11u8, 238u8, - 215u8, 190u8, 169u8, 119u8, 86u8, 69u8, 108u8, 87u8, 39u8, 65u8, 154u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for LightRelayEvents { - const NAME: &'static str = "LightRelayEvents"; - const COUNT: usize = 7usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::AuthorizationRequirementChanged) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::Genesis) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::OwnershipTransferred) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::ProofLengthChanged) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::Retarget) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::SubmitterAuthorized) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::SubmitterDeauthorized) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 LightRelayEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::AuthorizationRequirementChanged(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::Genesis(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::OwnershipTransferred(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::ProofLengthChanged(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::Retarget(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::SubmitterAuthorized(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::SubmitterDeauthorized(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::AuthorizationRequirementChanged(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::Genesis(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::OwnershipTransferred(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::ProofLengthChanged(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::Retarget(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::SubmitterAuthorized(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::SubmitterDeauthorized(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`LightRelay`](self) contract instance. - -See the [wrapper's documentation](`LightRelayInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> LightRelayInstance { - LightRelayInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - LightRelayInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - LightRelayInstance::::deploy_builder(provider) - } - /**A [`LightRelay`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`LightRelay`](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 LightRelayInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for LightRelayInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("LightRelayInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > LightRelayInstance { - /**Creates a new wrapper around an on-chain [`LightRelay`](self) contract instance. - -See the [wrapper's documentation](`LightRelayInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 LightRelayInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> LightRelayInstance { - LightRelayInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > LightRelayInstance { - /// 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( - &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 [`authorizationRequired`] function. - pub fn authorizationRequired( - &self, - ) -> alloy_contract::SolCallBuilder<&P, authorizationRequiredCall, N> { - self.call_builder(&authorizationRequiredCall) - } - ///Creates a new call builder for the [`authorize`] function. - pub fn authorize( - &self, - submitter: alloy::sol_types::private::Address, - ) -> alloy_contract::SolCallBuilder<&P, authorizeCall, N> { - self.call_builder(&authorizeCall { submitter }) - } - ///Creates a new call builder for the [`currentEpoch`] function. - pub fn currentEpoch( - &self, - ) -> alloy_contract::SolCallBuilder<&P, currentEpochCall, N> { - self.call_builder(¤tEpochCall) - } - ///Creates a new call builder for the [`deauthorize`] function. - pub fn deauthorize( - &self, - submitter: alloy::sol_types::private::Address, - ) -> alloy_contract::SolCallBuilder<&P, deauthorizeCall, N> { - self.call_builder(&deauthorizeCall { submitter }) - } - ///Creates a new call builder for the [`genesis`] function. - pub fn genesis( - &self, - genesisHeader: alloy::sol_types::private::Bytes, - genesisHeight: alloy::sol_types::private::primitives::aliases::U256, - genesisProofLength: u64, - ) -> alloy_contract::SolCallBuilder<&P, genesisCall, N> { - self.call_builder( - &genesisCall { - genesisHeader, - genesisHeight, - genesisProofLength, - }, - ) - } - ///Creates a new call builder for the [`genesisEpoch`] function. - pub fn genesisEpoch( - &self, - ) -> alloy_contract::SolCallBuilder<&P, genesisEpochCall, N> { - self.call_builder(&genesisEpochCall) - } - ///Creates a new call builder for the [`getBlockDifficulty`] function. - pub fn getBlockDifficulty( - &self, - blockNumber: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getBlockDifficultyCall, N> { - self.call_builder( - &getBlockDifficultyCall { - blockNumber, - }, - ) - } - ///Creates a new call builder for the [`getCurrentAndPrevEpochDifficulty`] function. - pub fn getCurrentAndPrevEpochDifficulty( - &self, - ) -> alloy_contract::SolCallBuilder< - &P, - getCurrentAndPrevEpochDifficultyCall, - N, - > { - self.call_builder(&getCurrentAndPrevEpochDifficultyCall) - } - ///Creates a new call builder for the [`getCurrentEpochDifficulty`] function. - pub fn getCurrentEpochDifficulty( - &self, - ) -> alloy_contract::SolCallBuilder<&P, getCurrentEpochDifficultyCall, N> { - self.call_builder(&getCurrentEpochDifficultyCall) - } - ///Creates a new call builder for the [`getEpochDifficulty`] function. - pub fn getEpochDifficulty( - &self, - epochNumber: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, getEpochDifficultyCall, N> { - self.call_builder( - &getEpochDifficultyCall { - epochNumber, - }, - ) - } - ///Creates a new call builder for the [`getPrevEpochDifficulty`] function. - pub fn getPrevEpochDifficulty( - &self, - ) -> alloy_contract::SolCallBuilder<&P, getPrevEpochDifficultyCall, N> { - self.call_builder(&getPrevEpochDifficultyCall) - } - ///Creates a new call builder for the [`getRelayRange`] function. - pub fn getRelayRange( - &self, - ) -> alloy_contract::SolCallBuilder<&P, getRelayRangeCall, N> { - self.call_builder(&getRelayRangeCall) - } - ///Creates a new call builder for the [`isAuthorized`] function. - pub fn isAuthorized( - &self, - _0: alloy::sol_types::private::Address, - ) -> alloy_contract::SolCallBuilder<&P, isAuthorizedCall, N> { - self.call_builder(&isAuthorizedCall(_0)) - } - ///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 [`proofLength`] function. - pub fn proofLength( - &self, - ) -> alloy_contract::SolCallBuilder<&P, proofLengthCall, N> { - self.call_builder(&proofLengthCall) - } - ///Creates a new call builder for the [`ready`] function. - pub fn ready(&self) -> alloy_contract::SolCallBuilder<&P, readyCall, N> { - self.call_builder(&readyCall) - } - ///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 [`retarget`] function. - pub fn retarget( - &self, - headers: alloy::sol_types::private::Bytes, - ) -> alloy_contract::SolCallBuilder<&P, retargetCall, N> { - self.call_builder(&retargetCall { headers }) - } - ///Creates a new call builder for the [`setAuthorizationStatus`] function. - pub fn setAuthorizationStatus( - &self, - status: bool, - ) -> alloy_contract::SolCallBuilder<&P, setAuthorizationStatusCall, N> { - self.call_builder( - &setAuthorizationStatusCall { - status, - }, - ) - } - ///Creates a new call builder for the [`setProofLength`] function. - pub fn setProofLength( - &self, - newLength: u64, - ) -> alloy_contract::SolCallBuilder<&P, setProofLengthCall, N> { - self.call_builder(&setProofLengthCall { newLength }) - } - ///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 [`validateChain`] function. - pub fn validateChain( - &self, - headers: alloy::sol_types::private::Bytes, - ) -> alloy_contract::SolCallBuilder<&P, validateChainCall, N> { - self.call_builder(&validateChainCall { headers }) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > LightRelayInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`AuthorizationRequirementChanged`] event. - pub fn AuthorizationRequirementChanged_filter( - &self, - ) -> alloy_contract::Event<&P, AuthorizationRequirementChanged, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`Genesis`] event. - pub fn Genesis_filter(&self) -> alloy_contract::Event<&P, Genesis, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`OwnershipTransferred`] event. - pub fn OwnershipTransferred_filter( - &self, - ) -> alloy_contract::Event<&P, OwnershipTransferred, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`ProofLengthChanged`] event. - pub fn ProofLengthChanged_filter( - &self, - ) -> alloy_contract::Event<&P, ProofLengthChanged, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`Retarget`] event. - pub fn Retarget_filter(&self) -> alloy_contract::Event<&P, Retarget, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`SubmitterAuthorized`] event. - pub fn SubmitterAuthorized_filter( - &self, - ) -> alloy_contract::Event<&P, SubmitterAuthorized, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`SubmitterDeauthorized`] event. - pub fn SubmitterDeauthorized_filter( - &self, - ) -> alloy_contract::Event<&P, SubmitterDeauthorized, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/market_place.rs b/crates/bindings/src/market_place.rs deleted file mode 100644 index 7ec855f89..000000000 --- a/crates/bindings/src/market_place.rs +++ /dev/null @@ -1,3197 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface MarketPlace { - struct Order { - uint256 offeringAmount; - address offeringToken; - uint256 askingAmount; - address askingToken; - address requesterAddress; - } - - event acceptOrder(uint256 indexed orderId, address indexed who, uint256 buyAmount, uint256 saleAmount); - event placeOrder(uint256 indexed orderId, address indexed requesterAddress, uint256 offeringAmount, address offeringToken, uint256 askingAmount, address askingToken); - event withdrawOrder(uint256 indexed orderId); - - constructor(address erc2771Forwarder); - - function acceptErcErcOrder(uint256 id, uint256 saleAmount) external; - function ercErcOrders(uint256) external view returns (uint256 offeringAmount, address offeringToken, uint256 askingAmount, address askingToken, address requesterAddress); - function getOpenOrders() external view returns (Order[] memory, uint256[] memory); - function getTrustedForwarder() external view returns (address forwarder); - function isTrustedForwarder(address forwarder) external view returns (bool); - function nextOrderId() external view returns (uint256); - function placeErcErcOrder(address sellingToken, uint256 saleAmount, address buyingToken, uint256 buyAmount) external; - function withdrawErcErcOrder(uint256 id) external; -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "erc2771Forwarder", - "type": "address", - "internalType": "address" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "acceptErcErcOrder", - "inputs": [ - { - "name": "id", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "saleAmount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "ercErcOrders", - "inputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "offeringAmount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "offeringToken", - "type": "address", - "internalType": "address" - }, - { - "name": "askingAmount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "askingToken", - "type": "address", - "internalType": "address" - }, - { - "name": "requesterAddress", - "type": "address", - "internalType": "address" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getOpenOrders", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "tuple[]", - "internalType": "struct MarketPlace.Order[]", - "components": [ - { - "name": "offeringAmount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "offeringToken", - "type": "address", - "internalType": "address" - }, - { - "name": "askingAmount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "askingToken", - "type": "address", - "internalType": "address" - }, - { - "name": "requesterAddress", - "type": "address", - "internalType": "address" - } - ] - }, - { - "name": "", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getTrustedForwarder", - "inputs": [], - "outputs": [ - { - "name": "forwarder", - "type": "address", - "internalType": "address" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "isTrustedForwarder", - "inputs": [ - { - "name": "forwarder", - "type": "address", - "internalType": "address" - } - ], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "nextOrderId", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "placeErcErcOrder", - "inputs": [ - { - "name": "sellingToken", - "type": "address", - "internalType": "address" - }, - { - "name": "saleAmount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "buyingToken", - "type": "address", - "internalType": "address" - }, - { - "name": "buyAmount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "withdrawErcErcOrder", - "inputs": [ - { - "name": "id", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "event", - "name": "acceptOrder", - "inputs": [ - { - "name": "orderId", - "type": "uint256", - "indexed": true, - "internalType": "uint256" - }, - { - "name": "who", - "type": "address", - "indexed": true, - "internalType": "address" - }, - { - "name": "buyAmount", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "saleAmount", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "placeOrder", - "inputs": [ - { - "name": "orderId", - "type": "uint256", - "indexed": true, - "internalType": "uint256" - }, - { - "name": "requesterAddress", - "type": "address", - "indexed": true, - "internalType": "address" - }, - { - "name": "offeringAmount", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "offeringToken", - "type": "address", - "indexed": false, - "internalType": "address" - }, - { - "name": "askingAmount", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "askingToken", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "withdrawOrder", - "inputs": [ - { - "name": "orderId", - "type": "uint256", - "indexed": true, - "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 MarketPlace { - use super::*; - use alloy::sol_types as 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[P`@Qa\x10=8\x03\x80a\x10=\x839\x81\x01`@\x81\x90R`+\x91`JV[_\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x83\x16\x17\x90UP`uV[_` \x82\x84\x03\x12\x15`YW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14`nW__\xFD[\x93\x92PPPV[a\x0F\xBB\x80a\0\x82_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\x85W_5`\xE0\x1C\x80c\\Yh\xBB\x11a\0XW\x80c\\Yh\xBB\x14a\0\xFEW\x80c\xCE\x1B\x81_\x14a\x01zW\x80c\xDB\xE5\xBA\xB5\x14a\x01\x94W\x80c\xF8\x18\x11p\x14a\x01\xAAW__\xFD[\x80c\x04\xBC\x1E{\x14a\0\x89W\x80c\"\xECT\xA0\x14a\0\x9EW\x80c*X\xB30\x14a\0\xB1W\x80cW+l\x05\x14a\0\xCDW[__\xFD[a\0\x9Ca\0\x976`\x04a\x0CAV[a\x01\xBDV[\0[a\0\x9Ca\0\xAC6`\x04a\x0CsV[a\x02\xE7V[a\0\xBA`\x02T\x81V[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\xEEa\0\xDB6`\x04a\x0C\xB4V[_T`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x91\x16\x14\x90V[`@Q\x90\x15\x15\x81R` \x01a\0\xC4V[a\x01Ha\x01\x0C6`\x04a\x0CAV[`\x01` \x81\x90R_\x91\x82R`@\x90\x91 \x80T\x91\x81\x01T`\x02\x82\x01T`\x03\x83\x01T`\x04\x90\x93\x01T`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x93\x91\x92\x91\x82\x16\x91\x16\x85V[`@\x80Q\x95\x86R`\x01`\x01`\xA0\x1B\x03\x94\x85\x16` \x87\x01R\x85\x01\x92\x90\x92R\x82\x16``\x84\x01R\x16`\x80\x82\x01R`\xA0\x01a\0\xC4V[_T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\0\xC4V[a\x01\x9Ca\x04rV[`@Qa\0\xC4\x92\x91\x90a\r\x07V[a\0\x9Ca\x01\xB86`\x04a\r\xA9V[a\x06>V[_\x81\x81R`\x01` \x81\x81R`@\x92\x83\x90 \x83Q`\xA0\x81\x01\x85R\x81T\x81R\x92\x81\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x92\x84\x01\x92\x90\x92R`\x02\x81\x01T\x93\x83\x01\x93\x90\x93R`\x03\x83\x01T\x81\x16``\x83\x01R`\x04\x90\x92\x01T\x90\x91\x16`\x80\x82\x01Ra\x02\x1Ea\x07\xE8V[`\x01`\x01`\xA0\x1B\x03\x16\x81`\x80\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x14a\x02>W__\xFD[a\x02`a\x02Ia\x07\xE8V[\x82Q` \x84\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x91\x90a\x088V[_\x82\x81R`\x01` \x81\x90R`@\x80\x83 \x83\x81U\x91\x82\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\x90\x81\x16\x90\x91U`\x02\x83\x01\x84\x90U`\x03\x83\x01\x80T\x82\x16\x90U`\x04\x90\x92\x01\x80T\x90\x92\x16\x90\x91UQ\x83\x91\x7F\xFBy\x1B\x0B\x90\xB7Jb\xA7\xD09X3b\xB4\xBE$K\x07\"rb##\x94\xE9#\xC1d\x88\xED1\x91\xA2PPV[`\x01`\x01`\xA0\x1B\x03\x84\x16a\x02\xF9W__\xFD[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x03\x0BW__\xFD[a\x03(a\x03\x16a\x07\xE8V[`\x01`\x01`\xA0\x1B\x03\x86\x16\x900\x86a\t\x04V[`\x02\x80T_\x91\x82a\x038\x83a\r\xF6V[\x91\x90PU\x90P_`@Q\x80`\xA0\x01`@R\x80\x86\x81R` \x01\x87`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x84\x81R` \x01\x85`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a\x03|a\x07\xE8V[`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x90\x91R_\x84\x81R`\x01` \x81\x81R`@\x92\x83\x90 \x85Q\x80\x82U\x91\x86\x01Q\x92\x81\x01\x80T\x84\x87\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\x84\x87\x01Q`\x02\x83\x01\x81\x90U``\x88\x01Q`\x03\x84\x01\x80T\x82\x8A\x16\x90\x85\x16\x17\x90U`\x80\x89\x01Q`\x04\x90\x94\x01\x80T\x94\x90\x98\x16\x93\x90\x92\x16\x83\x17\x90\x96U\x93Q\x95\x96P\x94\x87\x94\x7F\xC4\x04j0\\Y\xED\xB2G.c\x8A(\xCE\xDB\x16V<\x8A\xA0\xA4\xF8\xFA\xFF\xCA\xEF\x1CC\xA2o\x88l\x94a\x04b\x94\x92\x93\x84R`\x01`\x01`\xA0\x1B\x03\x92\x83\x16` \x85\x01R`@\x84\x01\x91\x90\x91R\x16``\x82\x01R`\x80\x01\x90V[`@Q\x80\x91\x03\x90\xA3PPPPPPV[``\x80_\x80[`\x02T\x81\x10\x15a\x04\xABW_\x81\x81R`\x01` R`@\x90 T\x15a\x04\xA3W\x81a\x04\x9F\x81a\r\xF6V[\x92PP[`\x01\x01a\x04xV[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x04\xC6Wa\x04\xC6a\x0E\x0EV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x05\x1DW\x81` \x01[`@\x80Q`\xA0\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x92\x82\x01\x81\x90R``\x82\x01\x81\x90R`\x80\x82\x01R\x82R_\x19\x90\x92\x01\x91\x01\x81a\x04\xE4W\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x05:Wa\x05:a\x0E\x0EV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x05cW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x02T\x81\x10\x15a\x062W_\x81\x81R`\x01` R`@\x90 T\x15a\x06*W_\x81\x81R`\x01` \x81\x81R`@\x92\x83\x90 \x83Q`\xA0\x81\x01\x85R\x81T\x81R\x92\x81\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x92\x84\x01\x92\x90\x92R`\x02\x81\x01T\x93\x83\x01\x93\x90\x93R`\x03\x83\x01T\x81\x16``\x83\x01R`\x04\x90\x92\x01T\x90\x91\x16`\x80\x82\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x05\xF3Wa\x05\xF3a\x0E;V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x06\x11Wa\x06\x11a\x0E;V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x06&\x81a\r\xF6V[\x92PP[`\x01\x01a\x05iV[P\x91\x95\x90\x94P\x92PPPV[_\x82\x81R`\x01` \x81\x81R`@\x92\x83\x90 \x83Q`\xA0\x81\x01\x85R\x81T\x81R\x92\x81\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x92\x84\x01\x92\x90\x92R`\x02\x81\x01T\x93\x83\x01\x93\x90\x93R`\x03\x83\x01T\x81\x16``\x83\x01R`\x04\x90\x92\x01T\x90\x91\x16`\x80\x82\x01\x81\x90Ra\x06\xA1W__\xFD[\x80`@\x01Q\x82\x11\x15a\x06\xB1W__\xFD[`@\x81\x01Q\x81Q_\x91\x90a\x06\xC5\x90\x85a\x0EhV[a\x06\xCF\x91\x90a\x0E\x85V[\x90P_\x83\x11a\x06\xE0Wa\x06\xE0a\x0E\xBDV[_\x81\x11a\x06\xEFWa\x06\xEFa\x0E\xBDV[\x81Q\x81\x11\x15a\x07\0Wa\x07\0a\x0E\xBDV[_\x84\x81R`\x01` R`@\x81 \x80T\x83\x92\x90a\x07\x1D\x90\x84\x90a\x0E\xEAV[\x90\x91UPP_\x84\x81R`\x01` R`@\x81 `\x02\x01\x80T\x85\x92\x90a\x07B\x90\x84\x90a\x0E\xEAV[\x90\x91UPa\x07n\x90Pa\x07Sa\x07\xE8V[`\x80\x84\x01Q``\x85\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x91\x90\x86a\t\x04V[a\x07\x8Ea\x07ya\x07\xE8V[` \x84\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x90\x83a\x088V[a\x07\x96a\x07\xE8V[`\x01`\x01`\xA0\x1B\x03\x16\x84\x7F\x01\x1F\xCFo\xC5?\xC7\x99q\xC9\xE9?\x9A\xDC\xEDl\x1F'#\x17{K\x92\xBE\x86\x10+\x05X\xFB\xB08\x83\x86`@Qa\x07\xDA\x92\x91\x90\x91\x82R` \x82\x01R`@\x01\x90V[`@Q\x80\x91\x03\x90\xA3PPPPV[_`\x146\x10\x80\x15\x90a\x08\x03WP_T`\x01`\x01`\xA0\x1B\x03\x163\x14[\x15a\x083WP\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xEC6\x015``\x1C\x90V[P3\x90V[`@Q`\x01`\x01`\xA0\x1B\x03\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x08\xFF\x90\x84\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\x90`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\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\t[V[PPPV[`@Q`\x01`\x01`\xA0\x1B\x03\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\tU\x90\x85\x90\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\x90`\x84\x01a\x08}V[PPPPV[_a\t\xAF\x82`@Q\x80`@\x01`@R\x80` \x81R` \x01\x7FSafeERC20: low-level call failed\x81RP\x85`\x01`\x01`\xA0\x1B\x03\x16a\n^\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x08\xFFW\x80\x80` \x01\x90Q\x81\x01\x90a\t\xCD\x91\x90a\x0E\xFDV[a\x08\xFFW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x01[`@Q\x80\x91\x03\x90\xFD[``a\nl\x84\x84_\x85a\nvV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x0B\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`&`$\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\nUV[`\x01`\x01`\xA0\x1B\x03\x85\x16;a\x0ByW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\nUV[__\x86`\x01`\x01`\xA0\x1B\x03\x16\x85\x87`@Qa\x0B\x94\x91\x90a\x0F\x1CV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x0B\xCEW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x0B\xD3V[``\x91P[P\x91P\x91Pa\x0B\xE3\x82\x82\x86a\x0B\xEEV[\x97\x96PPPPPPPV[``\x83\x15a\x0B\xFDWP\x81a\noV[\x82Q\x15a\x0C\rW\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\nU\x91\x90a\x0F2V[_` \x82\x84\x03\x12\x15a\x0CQW__\xFD[P5\x91\x90PV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0CnW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0C\x86W__\xFD[a\x0C\x8F\x85a\x0CXV[\x93P` \x85\x015\x92Pa\x0C\xA4`@\x86\x01a\x0CXV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[_` \x82\x84\x03\x12\x15a\x0C\xC4W__\xFD[a\no\x82a\x0CXV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x0C\xFDW\x81Q\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x0C\xDFV[P\x93\x94\x93PPPPV[`@\x80\x82R\x83Q\x90\x82\x01\x81\x90R_\x90` \x85\x01\x90``\x84\x01\x90\x83[\x81\x81\x10\x15a\r\x8BW\x83Q\x80Q\x84R`\x01`\x01`\xA0\x1B\x03` \x82\x01Q\x16` \x85\x01R`@\x81\x01Q`@\x85\x01R`\x01`\x01`\xA0\x1B\x03``\x82\x01Q\x16``\x85\x01R`\x01`\x01`\xA0\x1B\x03`\x80\x82\x01Q\x16`\x80\x85\x01RP`\xA0\x83\x01\x92P` \x84\x01\x93P`\x01\x81\x01\x90Pa\r\"V[PP\x83\x81\x03` \x85\x01Ra\r\x9F\x81\x86a\x0C\xCDV[\x96\x95PPPPPPV[__`@\x83\x85\x03\x12\x15a\r\xBAW__\xFD[PP\x805\x92` \x90\x91\x015\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`\x11`\x04R`$_\xFD[__\x19\x82\x03a\x0E\x07Wa\x0E\x07a\r\xC9V[P`\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`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[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x0E\x7FWa\x0E\x7Fa\r\xC9V[\x92\x91PPV[_\x82a\x0E\xB8W\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[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`\x01`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x0E\x7FWa\x0E\x7Fa\r\xC9V[_` \x82\x84\x03\x12\x15a\x0F\rW__\xFD[\x81Q\x80\x15\x15\x81\x14a\noW__\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`@\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x92\x91PPV\xFE\xA2dipfsX\"\x12 Y\xA4\x04\xB0~\xA6\x144*\xC4\x0E%\xDF:\x8E\x04$\xC2\xD4R_\xBE{\x9D\xF8\xB9B\xB6\x18j1\x08dsolcC\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\0\x85W_5`\xE0\x1C\x80c\\Yh\xBB\x11a\0XW\x80c\\Yh\xBB\x14a\0\xFEW\x80c\xCE\x1B\x81_\x14a\x01zW\x80c\xDB\xE5\xBA\xB5\x14a\x01\x94W\x80c\xF8\x18\x11p\x14a\x01\xAAW__\xFD[\x80c\x04\xBC\x1E{\x14a\0\x89W\x80c\"\xECT\xA0\x14a\0\x9EW\x80c*X\xB30\x14a\0\xB1W\x80cW+l\x05\x14a\0\xCDW[__\xFD[a\0\x9Ca\0\x976`\x04a\x0CAV[a\x01\xBDV[\0[a\0\x9Ca\0\xAC6`\x04a\x0CsV[a\x02\xE7V[a\0\xBA`\x02T\x81V[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\xEEa\0\xDB6`\x04a\x0C\xB4V[_T`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x91\x16\x14\x90V[`@Q\x90\x15\x15\x81R` \x01a\0\xC4V[a\x01Ha\x01\x0C6`\x04a\x0CAV[`\x01` \x81\x90R_\x91\x82R`@\x90\x91 \x80T\x91\x81\x01T`\x02\x82\x01T`\x03\x83\x01T`\x04\x90\x93\x01T`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x93\x91\x92\x91\x82\x16\x91\x16\x85V[`@\x80Q\x95\x86R`\x01`\x01`\xA0\x1B\x03\x94\x85\x16` \x87\x01R\x85\x01\x92\x90\x92R\x82\x16``\x84\x01R\x16`\x80\x82\x01R`\xA0\x01a\0\xC4V[_T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\0\xC4V[a\x01\x9Ca\x04rV[`@Qa\0\xC4\x92\x91\x90a\r\x07V[a\0\x9Ca\x01\xB86`\x04a\r\xA9V[a\x06>V[_\x81\x81R`\x01` \x81\x81R`@\x92\x83\x90 \x83Q`\xA0\x81\x01\x85R\x81T\x81R\x92\x81\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x92\x84\x01\x92\x90\x92R`\x02\x81\x01T\x93\x83\x01\x93\x90\x93R`\x03\x83\x01T\x81\x16``\x83\x01R`\x04\x90\x92\x01T\x90\x91\x16`\x80\x82\x01Ra\x02\x1Ea\x07\xE8V[`\x01`\x01`\xA0\x1B\x03\x16\x81`\x80\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x14a\x02>W__\xFD[a\x02`a\x02Ia\x07\xE8V[\x82Q` \x84\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x91\x90a\x088V[_\x82\x81R`\x01` \x81\x90R`@\x80\x83 \x83\x81U\x91\x82\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\x90\x81\x16\x90\x91U`\x02\x83\x01\x84\x90U`\x03\x83\x01\x80T\x82\x16\x90U`\x04\x90\x92\x01\x80T\x90\x92\x16\x90\x91UQ\x83\x91\x7F\xFBy\x1B\x0B\x90\xB7Jb\xA7\xD09X3b\xB4\xBE$K\x07\"rb##\x94\xE9#\xC1d\x88\xED1\x91\xA2PPV[`\x01`\x01`\xA0\x1B\x03\x84\x16a\x02\xF9W__\xFD[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x03\x0BW__\xFD[a\x03(a\x03\x16a\x07\xE8V[`\x01`\x01`\xA0\x1B\x03\x86\x16\x900\x86a\t\x04V[`\x02\x80T_\x91\x82a\x038\x83a\r\xF6V[\x91\x90PU\x90P_`@Q\x80`\xA0\x01`@R\x80\x86\x81R` \x01\x87`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01\x84\x81R` \x01\x85`\x01`\x01`\xA0\x1B\x03\x16\x81R` \x01a\x03|a\x07\xE8V[`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x90\x91R_\x84\x81R`\x01` \x81\x81R`@\x92\x83\x90 \x85Q\x80\x82U\x91\x86\x01Q\x92\x81\x01\x80T\x84\x87\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\x84\x87\x01Q`\x02\x83\x01\x81\x90U``\x88\x01Q`\x03\x84\x01\x80T\x82\x8A\x16\x90\x85\x16\x17\x90U`\x80\x89\x01Q`\x04\x90\x94\x01\x80T\x94\x90\x98\x16\x93\x90\x92\x16\x83\x17\x90\x96U\x93Q\x95\x96P\x94\x87\x94\x7F\xC4\x04j0\\Y\xED\xB2G.c\x8A(\xCE\xDB\x16V<\x8A\xA0\xA4\xF8\xFA\xFF\xCA\xEF\x1CC\xA2o\x88l\x94a\x04b\x94\x92\x93\x84R`\x01`\x01`\xA0\x1B\x03\x92\x83\x16` \x85\x01R`@\x84\x01\x91\x90\x91R\x16``\x82\x01R`\x80\x01\x90V[`@Q\x80\x91\x03\x90\xA3PPPPPPV[``\x80_\x80[`\x02T\x81\x10\x15a\x04\xABW_\x81\x81R`\x01` R`@\x90 T\x15a\x04\xA3W\x81a\x04\x9F\x81a\r\xF6V[\x92PP[`\x01\x01a\x04xV[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x04\xC6Wa\x04\xC6a\x0E\x0EV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x05\x1DW\x81` \x01[`@\x80Q`\xA0\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x92\x82\x01\x81\x90R``\x82\x01\x81\x90R`\x80\x82\x01R\x82R_\x19\x90\x92\x01\x91\x01\x81a\x04\xE4W\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x05:Wa\x05:a\x0E\x0EV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x05cW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x02T\x81\x10\x15a\x062W_\x81\x81R`\x01` R`@\x90 T\x15a\x06*W_\x81\x81R`\x01` \x81\x81R`@\x92\x83\x90 \x83Q`\xA0\x81\x01\x85R\x81T\x81R\x92\x81\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x92\x84\x01\x92\x90\x92R`\x02\x81\x01T\x93\x83\x01\x93\x90\x93R`\x03\x83\x01T\x81\x16``\x83\x01R`\x04\x90\x92\x01T\x90\x91\x16`\x80\x82\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x05\xF3Wa\x05\xF3a\x0E;V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x06\x11Wa\x06\x11a\x0E;V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x06&\x81a\r\xF6V[\x92PP[`\x01\x01a\x05iV[P\x91\x95\x90\x94P\x92PPPV[_\x82\x81R`\x01` \x81\x81R`@\x92\x83\x90 \x83Q`\xA0\x81\x01\x85R\x81T\x81R\x92\x81\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x92\x84\x01\x92\x90\x92R`\x02\x81\x01T\x93\x83\x01\x93\x90\x93R`\x03\x83\x01T\x81\x16``\x83\x01R`\x04\x90\x92\x01T\x90\x91\x16`\x80\x82\x01\x81\x90Ra\x06\xA1W__\xFD[\x80`@\x01Q\x82\x11\x15a\x06\xB1W__\xFD[`@\x81\x01Q\x81Q_\x91\x90a\x06\xC5\x90\x85a\x0EhV[a\x06\xCF\x91\x90a\x0E\x85V[\x90P_\x83\x11a\x06\xE0Wa\x06\xE0a\x0E\xBDV[_\x81\x11a\x06\xEFWa\x06\xEFa\x0E\xBDV[\x81Q\x81\x11\x15a\x07\0Wa\x07\0a\x0E\xBDV[_\x84\x81R`\x01` R`@\x81 \x80T\x83\x92\x90a\x07\x1D\x90\x84\x90a\x0E\xEAV[\x90\x91UPP_\x84\x81R`\x01` R`@\x81 `\x02\x01\x80T\x85\x92\x90a\x07B\x90\x84\x90a\x0E\xEAV[\x90\x91UPa\x07n\x90Pa\x07Sa\x07\xE8V[`\x80\x84\x01Q``\x85\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x91\x90\x86a\t\x04V[a\x07\x8Ea\x07ya\x07\xE8V[` \x84\x01Q`\x01`\x01`\xA0\x1B\x03\x16\x90\x83a\x088V[a\x07\x96a\x07\xE8V[`\x01`\x01`\xA0\x1B\x03\x16\x84\x7F\x01\x1F\xCFo\xC5?\xC7\x99q\xC9\xE9?\x9A\xDC\xEDl\x1F'#\x17{K\x92\xBE\x86\x10+\x05X\xFB\xB08\x83\x86`@Qa\x07\xDA\x92\x91\x90\x91\x82R` \x82\x01R`@\x01\x90V[`@Q\x80\x91\x03\x90\xA3PPPPV[_`\x146\x10\x80\x15\x90a\x08\x03WP_T`\x01`\x01`\xA0\x1B\x03\x163\x14[\x15a\x083WP\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xEC6\x015``\x1C\x90V[P3\x90V[`@Q`\x01`\x01`\xA0\x1B\x03\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x08\xFF\x90\x84\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\x90`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\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\t[V[PPPV[`@Q`\x01`\x01`\xA0\x1B\x03\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\tU\x90\x85\x90\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\x90`\x84\x01a\x08}V[PPPPV[_a\t\xAF\x82`@Q\x80`@\x01`@R\x80` \x81R` \x01\x7FSafeERC20: low-level call failed\x81RP\x85`\x01`\x01`\xA0\x1B\x03\x16a\n^\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x08\xFFW\x80\x80` \x01\x90Q\x81\x01\x90a\t\xCD\x91\x90a\x0E\xFDV[a\x08\xFFW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x01[`@Q\x80\x91\x03\x90\xFD[``a\nl\x84\x84_\x85a\nvV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x0B\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`&`$\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\nUV[`\x01`\x01`\xA0\x1B\x03\x85\x16;a\x0ByW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\nUV[__\x86`\x01`\x01`\xA0\x1B\x03\x16\x85\x87`@Qa\x0B\x94\x91\x90a\x0F\x1CV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x0B\xCEW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x0B\xD3V[``\x91P[P\x91P\x91Pa\x0B\xE3\x82\x82\x86a\x0B\xEEV[\x97\x96PPPPPPPV[``\x83\x15a\x0B\xFDWP\x81a\noV[\x82Q\x15a\x0C\rW\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\nU\x91\x90a\x0F2V[_` \x82\x84\x03\x12\x15a\x0CQW__\xFD[P5\x91\x90PV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0CnW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0C\x86W__\xFD[a\x0C\x8F\x85a\x0CXV[\x93P` \x85\x015\x92Pa\x0C\xA4`@\x86\x01a\x0CXV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[_` \x82\x84\x03\x12\x15a\x0C\xC4W__\xFD[a\no\x82a\x0CXV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x0C\xFDW\x81Q\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x0C\xDFV[P\x93\x94\x93PPPPV[`@\x80\x82R\x83Q\x90\x82\x01\x81\x90R_\x90` \x85\x01\x90``\x84\x01\x90\x83[\x81\x81\x10\x15a\r\x8BW\x83Q\x80Q\x84R`\x01`\x01`\xA0\x1B\x03` \x82\x01Q\x16` \x85\x01R`@\x81\x01Q`@\x85\x01R`\x01`\x01`\xA0\x1B\x03``\x82\x01Q\x16``\x85\x01R`\x01`\x01`\xA0\x1B\x03`\x80\x82\x01Q\x16`\x80\x85\x01RP`\xA0\x83\x01\x92P` \x84\x01\x93P`\x01\x81\x01\x90Pa\r\"V[PP\x83\x81\x03` \x85\x01Ra\r\x9F\x81\x86a\x0C\xCDV[\x96\x95PPPPPPV[__`@\x83\x85\x03\x12\x15a\r\xBAW__\xFD[PP\x805\x92` \x90\x91\x015\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`\x11`\x04R`$_\xFD[__\x19\x82\x03a\x0E\x07Wa\x0E\x07a\r\xC9V[P`\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`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[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x0E\x7FWa\x0E\x7Fa\r\xC9V[\x92\x91PPV[_\x82a\x0E\xB8W\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[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`\x01`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x0E\x7FWa\x0E\x7Fa\r\xC9V[_` \x82\x84\x03\x12\x15a\x0F\rW__\xFD[\x81Q\x80\x15\x15\x81\x14a\noW__\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`@\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x92\x91PPV\xFE\xA2dipfsX\"\x12 Y\xA4\x04\xB0~\xA6\x144*\xC4\x0E%\xDF:\x8E\x04$\xC2\xD4R_\xBE{\x9D\xF8\xB9B\xB6\x18j1\x08dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct Order { uint256 offeringAmount; address offeringToken; uint256 askingAmount; address askingToken; address requesterAddress; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct Order { - #[allow(missing_docs)] - pub offeringAmount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub offeringToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub askingAmount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub askingToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub requesterAddress: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - 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::Address, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: Order) -> Self { - ( - value.offeringAmount, - value.offeringToken, - value.askingAmount, - value.askingToken, - value.requesterAddress, - ) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for Order { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - offeringAmount: tuple.0, - offeringToken: tuple.1, - askingAmount: tuple.2, - askingToken: tuple.3, - requesterAddress: tuple.4, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for Order { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for Order { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.offeringAmount), - ::tokenize( - &self.offeringToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.askingAmount), - ::tokenize( - &self.askingToken, - ), - ::tokenize( - &self.requesterAddress, - ), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - 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> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::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(uint256 offeringAmount,address offeringToken,uint256 askingAmount,address askingToken,address requesterAddress)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - as alloy_sol_types::SolType>::eip712_data_word( - &self.offeringAmount, - ) - .0, - ::eip712_data_word( - &self.offeringToken, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.askingAmount) - .0, - ::eip712_data_word( - &self.askingToken, - ) - .0, - ::eip712_data_word( - &self.requesterAddress, - ) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for Order { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.offeringAmount, - ) - + ::topic_preimage_length( - &rust.offeringToken, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.askingAmount, - ) - + ::topic_preimage_length( - &rust.askingToken, - ) - + ::topic_preimage_length( - &rust.requesterAddress, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.offeringAmount, - out, - ); - ::encode_topic_preimage( - &rust.offeringToken, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.askingAmount, - out, - ); - ::encode_topic_preimage( - &rust.askingToken, - out, - ); - ::encode_topic_preimage( - &rust.requesterAddress, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `acceptOrder(uint256,address,uint256,uint256)` and selector `0x011fcf6fc53fc79971c9e93f9adced6c1f2723177b4b92be86102b0558fbb038`. -```solidity -event acceptOrder(uint256 indexed orderId, address indexed who, uint256 buyAmount, uint256 saleAmount); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct acceptOrder { - #[allow(missing_docs)] - pub orderId: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub who: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub buyAmount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub saleAmount: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for acceptOrder { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - ); - const SIGNATURE: &'static str = "acceptOrder(uint256,address,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 1u8, 31u8, 207u8, 111u8, 197u8, 63u8, 199u8, 153u8, 113u8, 201u8, 233u8, - 63u8, 154u8, 220u8, 237u8, 108u8, 31u8, 39u8, 35u8, 23u8, 123u8, 75u8, - 146u8, 190u8, 134u8, 16u8, 43u8, 5u8, 88u8, 251u8, 176u8, 56u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - orderId: topics.1, - who: topics.2, - buyAmount: data.0, - saleAmount: data.1, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.buyAmount), - as alloy_sol_types::SolType>::tokenize(&self.saleAmount), - ) - } - #[inline] - fn topics(&self) -> ::RustType { - (Self::SIGNATURE_HASH.into(), self.orderId.clone(), self.who.clone()) - } - #[inline] - fn encode_topics_raw( - &self, - out: &mut [alloy_sol_types::abi::token::WordToken], - ) -> alloy_sol_types::Result<()> { - if out.len() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.orderId); - out[2usize] = ::encode_topic( - &self.who, - ); - Ok(()) - } - } - #[automatically_derived] - impl alloy_sol_types::private::IntoLogData for acceptOrder { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&acceptOrder> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &acceptOrder) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `placeOrder(uint256,address,uint256,address,uint256,address)` and selector `0xc4046a305c59edb2472e638a28cedb16563c8aa0a4f8faffcaef1c43a26f886c`. -```solidity -event placeOrder(uint256 indexed orderId, address indexed requesterAddress, uint256 offeringAmount, address offeringToken, uint256 askingAmount, address askingToken); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct placeOrder { - #[allow(missing_docs)] - pub orderId: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub requesterAddress: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub offeringAmount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub offeringToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub askingAmount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub askingToken: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for placeOrder { - type DataTuple<'a> = ( - 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 DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - ); - const SIGNATURE: &'static str = "placeOrder(uint256,address,uint256,address,uint256,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 196u8, 4u8, 106u8, 48u8, 92u8, 89u8, 237u8, 178u8, 71u8, 46u8, 99u8, - 138u8, 40u8, 206u8, 219u8, 22u8, 86u8, 60u8, 138u8, 160u8, 164u8, 248u8, - 250u8, 255u8, 202u8, 239u8, 28u8, 67u8, 162u8, 111u8, 136u8, 108u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - orderId: topics.1, - requesterAddress: topics.2, - offeringAmount: data.0, - offeringToken: data.1, - askingAmount: data.2, - askingToken: data.3, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.offeringAmount), - ::tokenize( - &self.offeringToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.askingAmount), - ::tokenize( - &self.askingToken, - ), - ) - } - #[inline] - fn topics(&self) -> ::RustType { - ( - Self::SIGNATURE_HASH.into(), - self.orderId.clone(), - self.requesterAddress.clone(), - ) - } - #[inline] - fn encode_topics_raw( - &self, - out: &mut [alloy_sol_types::abi::token::WordToken], - ) -> alloy_sol_types::Result<()> { - if out.len() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.orderId); - out[2usize] = ::encode_topic( - &self.requesterAddress, - ); - Ok(()) - } - } - #[automatically_derived] - impl alloy_sol_types::private::IntoLogData for placeOrder { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&placeOrder> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &placeOrder) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `withdrawOrder(uint256)` and selector `0xfb791b0b90b74a62a7d039583362b4be244b07227262232394e923c16488ed31`. -```solidity -event withdrawOrder(uint256 indexed orderId); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct withdrawOrder { - #[allow(missing_docs)] - pub orderId: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for withdrawOrder { - type DataTuple<'a> = (); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Uint<256>, - ); - const SIGNATURE: &'static str = "withdrawOrder(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 121u8, 27u8, 11u8, 144u8, 183u8, 74u8, 98u8, 167u8, 208u8, 57u8, - 88u8, 51u8, 98u8, 180u8, 190u8, 36u8, 75u8, 7u8, 34u8, 114u8, 98u8, 35u8, - 35u8, 148u8, 233u8, 35u8, 193u8, 100u8, 136u8, 237u8, 49u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { orderId: topics.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return 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) -> ::RustType { - (Self::SIGNATURE_HASH.into(), self.orderId.clone()) - } - #[inline] - fn encode_topics_raw( - &self, - out: &mut [alloy_sol_types::abi::token::WordToken], - ) -> alloy_sol_types::Result<()> { - if out.len() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.orderId); - Ok(()) - } - } - #[automatically_derived] - impl alloy_sol_types::private::IntoLogData for withdrawOrder { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&withdrawOrder> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &withdrawOrder) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - /**Constructor`. -```solidity -constructor(address erc2771Forwarder); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct constructorCall { - #[allow(missing_docs)] - pub erc2771Forwarder: alloy::sol_types::private::Address, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value.erc2771Forwarder,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { erc2771Forwarder: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolConstructor for constructorCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.erc2771Forwarder, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `acceptErcErcOrder(uint256,uint256)` and selector `0xf8181170`. -```solidity -function acceptErcErcOrder(uint256 id, uint256 saleAmount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct acceptErcErcOrderCall { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub saleAmount: alloy::sol_types::private::primitives::aliases::U256, - } - ///Container type for the return parameters of the [`acceptErcErcOrder(uint256,uint256)`](acceptErcErcOrderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct acceptErcErcOrderReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: acceptErcErcOrderCall) -> Self { - (value.id, value.saleAmount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for acceptErcErcOrderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - id: tuple.0, - saleAmount: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: acceptErcErcOrderReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for acceptErcErcOrderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl acceptErcErcOrderReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for acceptErcErcOrderCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = acceptErcErcOrderReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "acceptErcErcOrder(uint256,uint256)"; - const SELECTOR: [u8; 4] = [248u8, 24u8, 17u8, 112u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - as alloy_sol_types::SolType>::tokenize(&self.saleAmount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - acceptErcErcOrderReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `ercErcOrders(uint256)` and selector `0x5c5968bb`. -```solidity -function ercErcOrders(uint256) external view returns (uint256 offeringAmount, address offeringToken, uint256 askingAmount, address askingToken, address requesterAddress); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct ercErcOrdersCall( - pub alloy::sol_types::private::primitives::aliases::U256, - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`ercErcOrders(uint256)`](ercErcOrdersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct ercErcOrdersReturn { - #[allow(missing_docs)] - pub offeringAmount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub offeringToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub askingAmount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub askingToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub requesterAddress: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: ercErcOrdersCall) -> Self { - (value.0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for ercErcOrdersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self(tuple.0) - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - 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::Address, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: ercErcOrdersReturn) -> Self { - ( - value.offeringAmount, - value.offeringToken, - value.askingAmount, - value.askingToken, - value.requesterAddress, - ) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for ercErcOrdersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - offeringAmount: tuple.0, - offeringToken: tuple.1, - askingAmount: tuple.2, - askingToken: tuple.3, - requesterAddress: tuple.4, - } - } - } - } - impl ercErcOrdersReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.offeringAmount), - ::tokenize( - &self.offeringToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.askingAmount), - ::tokenize( - &self.askingToken, - ), - ::tokenize( - &self.requesterAddress, - ), - ) - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for ercErcOrdersCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = ercErcOrdersReturn; - type ReturnTuple<'a> = ( - 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::Address, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "ercErcOrders(uint256)"; - const SELECTOR: [u8; 4] = [92u8, 89u8, 104u8, 187u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.0), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ercErcOrdersReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getOpenOrders()` and selector `0xdbe5bab5`. -```solidity -function getOpenOrders() external view returns (Order[] memory, uint256[] memory); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getOpenOrdersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getOpenOrders()`](getOpenOrdersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getOpenOrdersReturn { - #[allow(missing_docs)] - pub _0: alloy::sol_types::private::Vec< - ::RustType, - >, - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getOpenOrdersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getOpenOrdersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: getOpenOrdersReturn) -> Self { - (value._0, value._1) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for getOpenOrdersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0, _1: tuple.1 } - } - } - } - impl getOpenOrdersReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - , - > as alloy_sol_types::SolType>::tokenize(&self._1), - ) - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getOpenOrdersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = getOpenOrdersReturn; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - alloy::sol_types::sol_data::Array>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getOpenOrders()"; - const SELECTOR: [u8; 4] = [219u8, 229u8, 186u8, 181u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - getOpenOrdersReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getTrustedForwarder()` and selector `0xce1b815f`. -```solidity -function getTrustedForwarder() external view returns (address forwarder); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getTrustedForwarderCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getTrustedForwarder()`](getTrustedForwarderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getTrustedForwarderReturn { - #[allow(missing_docs)] - pub forwarder: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getTrustedForwarderCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getTrustedForwarderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getTrustedForwarderReturn) -> Self { - (value.forwarder,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getTrustedForwarderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { forwarder: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getTrustedForwarderCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getTrustedForwarder()"; - const SELECTOR: [u8; 4] = [206u8, 27u8, 129u8, 95u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getTrustedForwarderReturn = r.into(); - r.forwarder - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getTrustedForwarderReturn = r.into(); - r.forwarder - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `isTrustedForwarder(address)` and selector `0x572b6c05`. -```solidity -function isTrustedForwarder(address forwarder) external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct isTrustedForwarderCall { - #[allow(missing_docs)] - pub forwarder: alloy::sol_types::private::Address, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`isTrustedForwarder(address)`](isTrustedForwarderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct isTrustedForwarderReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: isTrustedForwarderCall) -> Self { - (value.forwarder,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for isTrustedForwarderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { forwarder: tuple.0 } - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: isTrustedForwarderReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for isTrustedForwarderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for isTrustedForwarderCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "isTrustedForwarder(address)"; - const SELECTOR: [u8; 4] = [87u8, 43u8, 108u8, 5u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.forwarder, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: isTrustedForwarderReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: isTrustedForwarderReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `nextOrderId()` and selector `0x2a58b330`. -```solidity -function nextOrderId() external view returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct nextOrderIdCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`nextOrderId()`](nextOrderIdCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct nextOrderIdReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: nextOrderIdCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for nextOrderIdCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: nextOrderIdReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for nextOrderIdReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for nextOrderIdCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "nextOrderId()"; - const SELECTOR: [u8; 4] = [42u8, 88u8, 179u8, 48u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: nextOrderIdReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: nextOrderIdReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `placeErcErcOrder(address,uint256,address,uint256)` and selector `0x22ec54a0`. -```solidity -function placeErcErcOrder(address sellingToken, uint256 saleAmount, address buyingToken, uint256 buyAmount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct placeErcErcOrderCall { - #[allow(missing_docs)] - pub sellingToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub saleAmount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub buyingToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub buyAmount: alloy::sol_types::private::primitives::aliases::U256, - } - ///Container type for the return parameters of the [`placeErcErcOrder(address,uint256,address,uint256)`](placeErcErcOrderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct placeErcErcOrderReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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>, - ); - #[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, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: placeErcErcOrderCall) -> Self { - ( - value.sellingToken, - value.saleAmount, - value.buyingToken, - value.buyAmount, - ) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for placeErcErcOrderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - sellingToken: tuple.0, - saleAmount: tuple.1, - buyingToken: tuple.2, - buyAmount: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: placeErcErcOrderReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for placeErcErcOrderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl placeErcErcOrderReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for placeErcErcOrderCall { - 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>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = placeErcErcOrderReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "placeErcErcOrder(address,uint256,address,uint256)"; - const SELECTOR: [u8; 4] = [34u8, 236u8, 84u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.sellingToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.saleAmount), - ::tokenize( - &self.buyingToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.buyAmount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - placeErcErcOrderReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `withdrawErcErcOrder(uint256)` and selector `0x04bc1e7b`. -```solidity -function withdrawErcErcOrder(uint256 id) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct withdrawErcErcOrderCall { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - } - ///Container type for the return parameters of the [`withdrawErcErcOrder(uint256)`](withdrawErcErcOrderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct withdrawErcErcOrderReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: withdrawErcErcOrderCall) -> Self { - (value.id,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for withdrawErcErcOrderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { id: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: withdrawErcErcOrderReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for withdrawErcErcOrderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl withdrawErcErcOrderReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for withdrawErcErcOrderCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = withdrawErcErcOrderReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "withdrawErcErcOrder(uint256)"; - const SELECTOR: [u8; 4] = [4u8, 188u8, 30u8, 123u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - withdrawErcErcOrderReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`MarketPlace`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum MarketPlaceCalls { - #[allow(missing_docs)] - acceptErcErcOrder(acceptErcErcOrderCall), - #[allow(missing_docs)] - ercErcOrders(ercErcOrdersCall), - #[allow(missing_docs)] - getOpenOrders(getOpenOrdersCall), - #[allow(missing_docs)] - getTrustedForwarder(getTrustedForwarderCall), - #[allow(missing_docs)] - isTrustedForwarder(isTrustedForwarderCall), - #[allow(missing_docs)] - nextOrderId(nextOrderIdCall), - #[allow(missing_docs)] - placeErcErcOrder(placeErcErcOrderCall), - #[allow(missing_docs)] - withdrawErcErcOrder(withdrawErcErcOrderCall), - } - #[automatically_derived] - impl MarketPlaceCalls { - /// 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]] = &[ - [4u8, 188u8, 30u8, 123u8], - [34u8, 236u8, 84u8, 160u8], - [42u8, 88u8, 179u8, 48u8], - [87u8, 43u8, 108u8, 5u8], - [92u8, 89u8, 104u8, 187u8], - [206u8, 27u8, 129u8, 95u8], - [219u8, 229u8, 186u8, 181u8], - [248u8, 24u8, 17u8, 112u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for MarketPlaceCalls { - const NAME: &'static str = "MarketPlaceCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 8usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::acceptErcErcOrder(_) => { - ::SELECTOR - } - Self::ercErcOrders(_) => { - ::SELECTOR - } - Self::getOpenOrders(_) => { - ::SELECTOR - } - Self::getTrustedForwarder(_) => { - ::SELECTOR - } - Self::isTrustedForwarder(_) => { - ::SELECTOR - } - Self::nextOrderId(_) => { - ::SELECTOR - } - Self::placeErcErcOrder(_) => { - ::SELECTOR - } - Self::withdrawErcErcOrder(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn withdrawErcErcOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(MarketPlaceCalls::withdrawErcErcOrder) - } - withdrawErcErcOrder - }, - { - fn placeErcErcOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(MarketPlaceCalls::placeErcErcOrder) - } - placeErcErcOrder - }, - { - fn nextOrderId( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(MarketPlaceCalls::nextOrderId) - } - nextOrderId - }, - { - fn isTrustedForwarder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(MarketPlaceCalls::isTrustedForwarder) - } - isTrustedForwarder - }, - { - fn ercErcOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(MarketPlaceCalls::ercErcOrders) - } - ercErcOrders - }, - { - fn getTrustedForwarder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(MarketPlaceCalls::getTrustedForwarder) - } - getTrustedForwarder - }, - { - fn getOpenOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(MarketPlaceCalls::getOpenOrders) - } - getOpenOrders - }, - { - fn acceptErcErcOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(MarketPlaceCalls::acceptErcErcOrder) - } - acceptErcErcOrder - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn withdrawErcErcOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(MarketPlaceCalls::withdrawErcErcOrder) - } - withdrawErcErcOrder - }, - { - fn placeErcErcOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(MarketPlaceCalls::placeErcErcOrder) - } - placeErcErcOrder - }, - { - fn nextOrderId( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(MarketPlaceCalls::nextOrderId) - } - nextOrderId - }, - { - fn isTrustedForwarder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(MarketPlaceCalls::isTrustedForwarder) - } - isTrustedForwarder - }, - { - fn ercErcOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(MarketPlaceCalls::ercErcOrders) - } - ercErcOrders - }, - { - fn getTrustedForwarder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(MarketPlaceCalls::getTrustedForwarder) - } - getTrustedForwarder - }, - { - fn getOpenOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(MarketPlaceCalls::getOpenOrders) - } - getOpenOrders - }, - { - fn acceptErcErcOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(MarketPlaceCalls::acceptErcErcOrder) - } - acceptErcErcOrder - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::acceptErcErcOrder(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::ercErcOrders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getOpenOrders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getTrustedForwarder(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::isTrustedForwarder(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::nextOrderId(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::placeErcErcOrder(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::withdrawErcErcOrder(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::acceptErcErcOrder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::ercErcOrders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getOpenOrders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getTrustedForwarder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::isTrustedForwarder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::nextOrderId(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::placeErcErcOrder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::withdrawErcErcOrder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`MarketPlace`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum MarketPlaceEvents { - #[allow(missing_docs)] - acceptOrder(acceptOrder), - #[allow(missing_docs)] - placeOrder(placeOrder), - #[allow(missing_docs)] - withdrawOrder(withdrawOrder), - } - #[automatically_derived] - impl MarketPlaceEvents { - /// 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, 31u8, 207u8, 111u8, 197u8, 63u8, 199u8, 153u8, 113u8, 201u8, 233u8, - 63u8, 154u8, 220u8, 237u8, 108u8, 31u8, 39u8, 35u8, 23u8, 123u8, 75u8, - 146u8, 190u8, 134u8, 16u8, 43u8, 5u8, 88u8, 251u8, 176u8, 56u8, - ], - [ - 196u8, 4u8, 106u8, 48u8, 92u8, 89u8, 237u8, 178u8, 71u8, 46u8, 99u8, - 138u8, 40u8, 206u8, 219u8, 22u8, 86u8, 60u8, 138u8, 160u8, 164u8, 248u8, - 250u8, 255u8, 202u8, 239u8, 28u8, 67u8, 162u8, 111u8, 136u8, 108u8, - ], - [ - 251u8, 121u8, 27u8, 11u8, 144u8, 183u8, 74u8, 98u8, 167u8, 208u8, 57u8, - 88u8, 51u8, 98u8, 180u8, 190u8, 36u8, 75u8, 7u8, 34u8, 114u8, 98u8, 35u8, - 35u8, 148u8, 233u8, 35u8, 193u8, 100u8, 136u8, 237u8, 49u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for MarketPlaceEvents { - const NAME: &'static str = "MarketPlaceEvents"; - const COUNT: usize = 3usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::acceptOrder) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::placeOrder) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::withdrawOrder) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 MarketPlaceEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::acceptOrder(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::placeOrder(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::withdrawOrder(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::acceptOrder(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::placeOrder(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::withdrawOrder(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`MarketPlace`](self) contract instance. - -See the [wrapper's documentation](`MarketPlaceInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> MarketPlaceInstance { - MarketPlaceInstance::::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: alloy_contract::private::Network, - >( - provider: P, - erc2771Forwarder: alloy::sol_types::private::Address, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - MarketPlaceInstance::::deploy(provider, erc2771Forwarder) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - erc2771Forwarder: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - MarketPlaceInstance::::deploy_builder(provider, erc2771Forwarder) - } - /**A [`MarketPlace`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`MarketPlace`](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 MarketPlaceInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for MarketPlaceInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("MarketPlaceInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > MarketPlaceInstance { - /**Creates a new wrapper around an on-chain [`MarketPlace`](self) contract instance. - -See the [wrapper's documentation](`MarketPlaceInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - erc2771Forwarder: alloy::sol_types::private::Address, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder(provider, erc2771Forwarder); - 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, - erc2771Forwarder: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { - erc2771Forwarder, - }, - )[..], - ] - .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 MarketPlaceInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> MarketPlaceInstance { - MarketPlaceInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > MarketPlaceInstance { - /// 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( - &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 [`acceptErcErcOrder`] function. - pub fn acceptErcErcOrder( - &self, - id: alloy::sol_types::private::primitives::aliases::U256, - saleAmount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, acceptErcErcOrderCall, N> { - self.call_builder( - &acceptErcErcOrderCall { - id, - saleAmount, - }, - ) - } - ///Creates a new call builder for the [`ercErcOrders`] function. - pub fn ercErcOrders( - &self, - _0: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, ercErcOrdersCall, N> { - self.call_builder(&ercErcOrdersCall(_0)) - } - ///Creates a new call builder for the [`getOpenOrders`] function. - pub fn getOpenOrders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, getOpenOrdersCall, N> { - self.call_builder(&getOpenOrdersCall) - } - ///Creates a new call builder for the [`getTrustedForwarder`] function. - pub fn getTrustedForwarder( - &self, - ) -> alloy_contract::SolCallBuilder<&P, getTrustedForwarderCall, N> { - self.call_builder(&getTrustedForwarderCall) - } - ///Creates a new call builder for the [`isTrustedForwarder`] function. - pub fn isTrustedForwarder( - &self, - forwarder: alloy::sol_types::private::Address, - ) -> alloy_contract::SolCallBuilder<&P, isTrustedForwarderCall, N> { - self.call_builder( - &isTrustedForwarderCall { - forwarder, - }, - ) - } - ///Creates a new call builder for the [`nextOrderId`] function. - pub fn nextOrderId( - &self, - ) -> alloy_contract::SolCallBuilder<&P, nextOrderIdCall, N> { - self.call_builder(&nextOrderIdCall) - } - ///Creates a new call builder for the [`placeErcErcOrder`] function. - pub fn placeErcErcOrder( - &self, - sellingToken: alloy::sol_types::private::Address, - saleAmount: alloy::sol_types::private::primitives::aliases::U256, - buyingToken: alloy::sol_types::private::Address, - buyAmount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, placeErcErcOrderCall, N> { - self.call_builder( - &placeErcErcOrderCall { - sellingToken, - saleAmount, - buyingToken, - buyAmount, - }, - ) - } - ///Creates a new call builder for the [`withdrawErcErcOrder`] function. - pub fn withdrawErcErcOrder( - &self, - id: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, withdrawErcErcOrderCall, N> { - self.call_builder(&withdrawErcErcOrderCall { id }) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > MarketPlaceInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`acceptOrder`] event. - pub fn acceptOrder_filter(&self) -> alloy_contract::Event<&P, acceptOrder, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`placeOrder`] event. - pub fn placeOrder_filter(&self) -> alloy_contract::Event<&P, placeOrder, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`withdrawOrder`] event. - pub fn withdrawOrder_filter( - &self, - ) -> alloy_contract::Event<&P, withdrawOrder, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/ord_marketplace.rs b/crates/bindings/src/ord_marketplace.rs deleted file mode 100644 index a21782d35..000000000 --- a/crates/bindings/src/ord_marketplace.rs +++ /dev/null @@ -1,6113 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library BitcoinTx { - struct Info { bytes4 version; bytes inputVector; bytes outputVector; bytes4 locktime; } - struct Proof { bytes merkleProof; uint256 txIndexInBlock; bytes bitcoinHeaders; bytes32 coinbasePreimage; bytes coinbaseProof; } - struct UTXO { bytes32 txHash; uint32 txOutputIndex; uint64 txOutputValue; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod BitcoinTx { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct Info { bytes4 version; bytes inputVector; bytes outputVector; bytes4 locktime; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct Info { - #[allow(missing_docs)] - pub version: alloy::sol_types::private::FixedBytes<4>, - #[allow(missing_docs)] - pub inputVector: alloy::sol_types::private::Bytes, - #[allow(missing_docs)] - pub outputVector: alloy::sol_types::private::Bytes, - #[allow(missing_docs)] - pub locktime: 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::FixedBytes<4>, - alloy::sol_types::sol_data::Bytes, - alloy::sol_types::sol_data::Bytes, - alloy::sol_types::sol_data::FixedBytes<4>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::FixedBytes<4>, - alloy::sol_types::private::Bytes, - alloy::sol_types::private::Bytes, - alloy::sol_types::private::FixedBytes<4>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: Info) -> Self { - (value.version, value.inputVector, value.outputVector, value.locktime) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for Info { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - version: tuple.0, - inputVector: tuple.1, - outputVector: tuple.2, - locktime: tuple.3, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for Info { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for Info { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.version), - ::tokenize( - &self.inputVector, - ), - ::tokenize( - &self.outputVector, - ), - as alloy_sol_types::SolType>::tokenize(&self.locktime), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for Info { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for Info { - const NAME: &'static str = "Info"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "Info(bytes4 version,bytes inputVector,bytes outputVector,bytes4 locktime)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - as alloy_sol_types::SolType>::eip712_data_word(&self.version) - .0, - ::eip712_data_word( - &self.inputVector, - ) - .0, - ::eip712_data_word( - &self.outputVector, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.locktime) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for Info { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.version, - ) - + ::topic_preimage_length( - &rust.inputVector, - ) - + ::topic_preimage_length( - &rust.outputVector, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.locktime, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.version, - out, - ); - ::encode_topic_preimage( - &rust.inputVector, - out, - ); - ::encode_topic_preimage( - &rust.outputVector, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.locktime, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct Proof { bytes merkleProof; uint256 txIndexInBlock; bytes bitcoinHeaders; bytes32 coinbasePreimage; bytes coinbaseProof; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct Proof { - #[allow(missing_docs)] - pub merkleProof: alloy::sol_types::private::Bytes, - #[allow(missing_docs)] - pub txIndexInBlock: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub bitcoinHeaders: alloy::sol_types::private::Bytes, - #[allow(missing_docs)] - pub coinbasePreimage: alloy::sol_types::private::FixedBytes<32>, - #[allow(missing_docs)] - pub coinbaseProof: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Bytes, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Bytes, - alloy::sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Bytes, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Bytes, - alloy::sol_types::private::primitives::aliases::U256, - alloy::sol_types::private::Bytes, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: Proof) -> Self { - ( - value.merkleProof, - value.txIndexInBlock, - value.bitcoinHeaders, - value.coinbasePreimage, - value.coinbaseProof, - ) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for Proof { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - merkleProof: tuple.0, - txIndexInBlock: tuple.1, - bitcoinHeaders: tuple.2, - coinbasePreimage: tuple.3, - coinbaseProof: tuple.4, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for Proof { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for Proof { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.merkleProof, - ), - as alloy_sol_types::SolType>::tokenize(&self.txIndexInBlock), - ::tokenize( - &self.bitcoinHeaders, - ), - as alloy_sol_types::SolType>::tokenize(&self.coinbasePreimage), - ::tokenize( - &self.coinbaseProof, - ), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for Proof { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for Proof { - const NAME: &'static str = "Proof"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "Proof(bytes merkleProof,uint256 txIndexInBlock,bytes bitcoinHeaders,bytes32 coinbasePreimage,bytes coinbaseProof)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.merkleProof, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word( - &self.txIndexInBlock, - ) - .0, - ::eip712_data_word( - &self.bitcoinHeaders, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word( - &self.coinbasePreimage, - ) - .0, - ::eip712_data_word( - &self.coinbaseProof, - ) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for Proof { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.merkleProof, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.txIndexInBlock, - ) - + ::topic_preimage_length( - &rust.bitcoinHeaders, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.coinbasePreimage, - ) - + ::topic_preimage_length( - &rust.coinbaseProof, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.merkleProof, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.txIndexInBlock, - out, - ); - ::encode_topic_preimage( - &rust.bitcoinHeaders, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.coinbasePreimage, - out, - ); - ::encode_topic_preimage( - &rust.coinbaseProof, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct UTXO { bytes32 txHash; uint32 txOutputIndex; uint64 txOutputValue; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct UTXO { - #[allow(missing_docs)] - pub txHash: alloy::sol_types::private::FixedBytes<32>, - #[allow(missing_docs)] - pub txOutputIndex: u32, - #[allow(missing_docs)] - pub txOutputValue: u64, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Uint<32>, - alloy::sol_types::sol_data::Uint<64>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::FixedBytes<32>, - u32, - u64, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: UTXO) -> Self { - (value.txHash, value.txOutputIndex, value.txOutputValue) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for UTXO { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - txHash: tuple.0, - txOutputIndex: tuple.1, - txOutputValue: tuple.2, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for UTXO { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for UTXO { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.txHash), - as alloy_sol_types::SolType>::tokenize(&self.txOutputIndex), - as alloy_sol_types::SolType>::tokenize(&self.txOutputValue), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for UTXO { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for UTXO { - const NAME: &'static str = "UTXO"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "UTXO(bytes32 txHash,uint32 txOutputIndex,uint64 txOutputValue)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - as alloy_sol_types::SolType>::eip712_data_word(&self.txHash) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.txOutputIndex) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.txOutputValue) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for UTXO { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.txHash, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.txOutputIndex, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.txOutputValue, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.txHash, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.txOutputIndex, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.txOutputValue, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`BitcoinTx`](self) contract instance. - -See the [wrapper's documentation](`BitcoinTxInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> BitcoinTxInstance { - BitcoinTxInstance::::new(address, provider) - } - /**A [`BitcoinTx`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`BitcoinTx`](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 BitcoinTxInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for BitcoinTxInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("BitcoinTxInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BitcoinTxInstance { - /**Creates a new wrapper around an on-chain [`BitcoinTx`](self) contract instance. - -See the [wrapper's documentation](`BitcoinTxInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 BitcoinTxInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> BitcoinTxInstance { - BitcoinTxInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BitcoinTxInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BitcoinTxInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library BitcoinTx { - struct Info { - bytes4 version; - bytes inputVector; - bytes outputVector; - bytes4 locktime; - } - struct Proof { - bytes merkleProof; - uint256 txIndexInBlock; - bytes bitcoinHeaders; - bytes32 coinbasePreimage; - bytes coinbaseProof; - } - struct UTXO { - bytes32 txHash; - uint32 txOutputIndex; - uint64 txOutputValue; - } -} - -interface OrdMarketplace { - struct AcceptedOrdinalSellOrder { - uint256 orderId; - BitcoinAddress bitcoinAddress; - address ercToken; - uint256 ercAmount; - address requester; - address acceptor; - uint256 acceptTime; - } - struct BitcoinAddress { - bytes scriptPubKey; - } - struct OrdinalId { - bytes32 txId; - uint32 index; - } - struct OrdinalSellOrder { - OrdinalId ordinalID; - address sellToken; - uint256 sellAmount; - BitcoinTx.UTXO utxo; - address requester; - bool isOrderAccepted; - } - - event acceptOrdinalSellOrderEvent(uint256 indexed id, uint256 indexed acceptId, BitcoinAddress bitcoinAddress, address ercToken, uint256 ercAmount); - event cancelAcceptedOrdinalSellOrderEvent(uint256 id); - event placeOrdinalSellOrderEvent(uint256 indexed orderId, OrdinalId ordinalID, address sellToken, uint256 sellAmount); - event proofOrdinalSellOrderEvent(uint256 id); - event withdrawOrdinalSellOrderEvent(uint256 id); - - constructor(address _relay); - - function REQUEST_EXPIRATION_SECONDS() external view returns (uint256); - function acceptOrdinalSellOrder(uint256 id, BitcoinAddress memory bitcoinAddress) external returns (uint256); - function acceptedOrdinalSellOrders(uint256) external view returns (uint256 orderId, BitcoinAddress memory bitcoinAddress, address ercToken, uint256 ercAmount, address requester, address acceptor, uint256 acceptTime); - function cancelAcceptedOrdinalSellOrder(uint256 id) external; - function getOpenAcceptedOrdinalSellOrders() external view returns (AcceptedOrdinalSellOrder[] memory, uint256[] memory); - function getOpenOrdinalSellOrders() external view returns (OrdinalSellOrder[] memory, uint256[] memory); - function ordinalSellOrders(uint256) external view returns (OrdinalId memory ordinalID, address sellToken, uint256 sellAmount, BitcoinTx.UTXO memory utxo, address requester, bool isOrderAccepted); - function placeOrdinalSellOrder(OrdinalId memory ordinalID, BitcoinTx.UTXO memory utxo, address sellToken, uint256 sellAmount) external; - function proofOrdinalSellOrder(uint256 id, BitcoinTx.Info memory transaction, BitcoinTx.Proof memory proof) external; - function withdrawOrdinalSellOrder(uint256 id) external; -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "_relay", - "type": "address", - "internalType": "contract TestLightRelay" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "REQUEST_EXPIRATION_SECONDS", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "acceptOrdinalSellOrder", - "inputs": [ - { - "name": "id", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "bitcoinAddress", - "type": "tuple", - "internalType": "struct OrdMarketplace.BitcoinAddress", - "components": [ - { - "name": "scriptPubKey", - "type": "bytes", - "internalType": "bytes" - } - ] - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "acceptedOrdinalSellOrders", - "inputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "orderId", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "bitcoinAddress", - "type": "tuple", - "internalType": "struct OrdMarketplace.BitcoinAddress", - "components": [ - { - "name": "scriptPubKey", - "type": "bytes", - "internalType": "bytes" - } - ] - }, - { - "name": "ercToken", - "type": "address", - "internalType": "address" - }, - { - "name": "ercAmount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "requester", - "type": "address", - "internalType": "address" - }, - { - "name": "acceptor", - "type": "address", - "internalType": "address" - }, - { - "name": "acceptTime", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "cancelAcceptedOrdinalSellOrder", - "inputs": [ - { - "name": "id", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "getOpenAcceptedOrdinalSellOrders", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "tuple[]", - "internalType": "struct OrdMarketplace.AcceptedOrdinalSellOrder[]", - "components": [ - { - "name": "orderId", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "bitcoinAddress", - "type": "tuple", - "internalType": "struct OrdMarketplace.BitcoinAddress", - "components": [ - { - "name": "scriptPubKey", - "type": "bytes", - "internalType": "bytes" - } - ] - }, - { - "name": "ercToken", - "type": "address", - "internalType": "address" - }, - { - "name": "ercAmount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "requester", - "type": "address", - "internalType": "address" - }, - { - "name": "acceptor", - "type": "address", - "internalType": "address" - }, - { - "name": "acceptTime", - "type": "uint256", - "internalType": "uint256" - } - ] - }, - { - "name": "", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "getOpenOrdinalSellOrders", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "tuple[]", - "internalType": "struct OrdMarketplace.OrdinalSellOrder[]", - "components": [ - { - "name": "ordinalID", - "type": "tuple", - "internalType": "struct OrdMarketplace.OrdinalId", - "components": [ - { - "name": "txId", - "type": "bytes32", - "internalType": "bytes32" - }, - { - "name": "index", - "type": "uint32", - "internalType": "uint32" - } - ] - }, - { - "name": "sellToken", - "type": "address", - "internalType": "address" - }, - { - "name": "sellAmount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "utxo", - "type": "tuple", - "internalType": "struct BitcoinTx.UTXO", - "components": [ - { - "name": "txHash", - "type": "bytes32", - "internalType": "bytes32" - }, - { - "name": "txOutputIndex", - "type": "uint32", - "internalType": "uint32" - }, - { - "name": "txOutputValue", - "type": "uint64", - "internalType": "uint64" - } - ] - }, - { - "name": "requester", - "type": "address", - "internalType": "address" - }, - { - "name": "isOrderAccepted", - "type": "bool", - "internalType": "bool" - } - ] - }, - { - "name": "", - "type": "uint256[]", - "internalType": "uint256[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "ordinalSellOrders", - "inputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "ordinalID", - "type": "tuple", - "internalType": "struct OrdMarketplace.OrdinalId", - "components": [ - { - "name": "txId", - "type": "bytes32", - "internalType": "bytes32" - }, - { - "name": "index", - "type": "uint32", - "internalType": "uint32" - } - ] - }, - { - "name": "sellToken", - "type": "address", - "internalType": "address" - }, - { - "name": "sellAmount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "utxo", - "type": "tuple", - "internalType": "struct BitcoinTx.UTXO", - "components": [ - { - "name": "txHash", - "type": "bytes32", - "internalType": "bytes32" - }, - { - "name": "txOutputIndex", - "type": "uint32", - "internalType": "uint32" - }, - { - "name": "txOutputValue", - "type": "uint64", - "internalType": "uint64" - } - ] - }, - { - "name": "requester", - "type": "address", - "internalType": "address" - }, - { - "name": "isOrderAccepted", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "placeOrdinalSellOrder", - "inputs": [ - { - "name": "ordinalID", - "type": "tuple", - "internalType": "struct OrdMarketplace.OrdinalId", - "components": [ - { - "name": "txId", - "type": "bytes32", - "internalType": "bytes32" - }, - { - "name": "index", - "type": "uint32", - "internalType": "uint32" - } - ] - }, - { - "name": "utxo", - "type": "tuple", - "internalType": "struct BitcoinTx.UTXO", - "components": [ - { - "name": "txHash", - "type": "bytes32", - "internalType": "bytes32" - }, - { - "name": "txOutputIndex", - "type": "uint32", - "internalType": "uint32" - }, - { - "name": "txOutputValue", - "type": "uint64", - "internalType": "uint64" - } - ] - }, - { - "name": "sellToken", - "type": "address", - "internalType": "address" - }, - { - "name": "sellAmount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "proofOrdinalSellOrder", - "inputs": [ - { - "name": "id", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "transaction", - "type": "tuple", - "internalType": "struct BitcoinTx.Info", - "components": [ - { - "name": "version", - "type": "bytes4", - "internalType": "bytes4" - }, - { - "name": "inputVector", - "type": "bytes", - "internalType": "bytes" - }, - { - "name": "outputVector", - "type": "bytes", - "internalType": "bytes" - }, - { - "name": "locktime", - "type": "bytes4", - "internalType": "bytes4" - } - ] - }, - { - "name": "proof", - "type": "tuple", - "internalType": "struct BitcoinTx.Proof", - "components": [ - { - "name": "merkleProof", - "type": "bytes", - "internalType": "bytes" - }, - { - "name": "txIndexInBlock", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "bitcoinHeaders", - "type": "bytes", - "internalType": "bytes" - }, - { - "name": "coinbasePreimage", - "type": "bytes32", - "internalType": "bytes32" - }, - { - "name": "coinbaseProof", - "type": "bytes", - "internalType": "bytes" - } - ] - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "withdrawOrdinalSellOrder", - "inputs": [ - { - "name": "id", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "event", - "name": "acceptOrdinalSellOrderEvent", - "inputs": [ - { - "name": "id", - "type": "uint256", - "indexed": true, - "internalType": "uint256" - }, - { - "name": "acceptId", - "type": "uint256", - "indexed": true, - "internalType": "uint256" - }, - { - "name": "bitcoinAddress", - "type": "tuple", - "indexed": false, - "internalType": "struct OrdMarketplace.BitcoinAddress", - "components": [ - { - "name": "scriptPubKey", - "type": "bytes", - "internalType": "bytes" - } - ] - }, - { - "name": "ercToken", - "type": "address", - "indexed": false, - "internalType": "address" - }, - { - "name": "ercAmount", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "cancelAcceptedOrdinalSellOrderEvent", - "inputs": [ - { - "name": "id", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "placeOrdinalSellOrderEvent", - "inputs": [ - { - "name": "orderId", - "type": "uint256", - "indexed": true, - "internalType": "uint256" - }, - { - "name": "ordinalID", - "type": "tuple", - "indexed": false, - "internalType": "struct OrdMarketplace.OrdinalId", - "components": [ - { - "name": "txId", - "type": "bytes32", - "internalType": "bytes32" - }, - { - "name": "index", - "type": "uint32", - "internalType": "uint32" - } - ] - }, - { - "name": "sellToken", - "type": "address", - "indexed": false, - "internalType": "address" - }, - { - "name": "sellAmount", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "proofOrdinalSellOrderEvent", - "inputs": [ - { - "name": "id", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "withdrawOrdinalSellOrderEvent", - "inputs": [ - { - "name": "id", - "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 OrdMarketplace { - use super::*; - use alloy::sol_types as 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[P`@Qa>\x158\x03\x80a>\x15\x839\x81\x01`@\x81\x90R`+\x91`PV[`\x03\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x83\x16\x17\x90UP`\x01`\x04U`{V[_` \x82\x84\x03\x12\x15`_W__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14`tW__\xFD[\x93\x92PPPV[a=\x8D\x80a\0\x88_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xB9W_5`\xE0\x1C\x80c\\\x9D\xDC\x84\x11a\0rW\x80c\xD1\x92\x0F\xF0\x11a\0XW\x80c\xD1\x92\x0F\xF0\x14a\x02\x13W\x80c\xDB\x82\xD5\xFA\x14a\x02\x1CW\x80c\xE4\xAEa\xDD\x14a\x02BW__\xFD[\x80c\\\x9D\xDC\x84\x14a\x01\xEDW\x80csxqU\x14a\x02\0W__\xFD[\x80c+&\x0F\xA0\x11a\0\xA2W\x80c+&\x0F\xA0\x14a\0\xFDW\x80c-sY\xC6\x14a\x01\xC2W\x80c=_\xFD[PPPPa\x08>`\x04T\x85a\x08!\x90a7yV[a\x08*\x86a8'V[`\x03T`\x01`\x01`\xA0\x1B\x03\x16\x92\x91\x90a\x14UV[Pa\x08\xC4a\x08O` \x86\x01\x86a6\xD1V[\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\x91RPP`@\x80Q``\x81\x01\x82R`\x04\x87\x01T\x81R`\x05\x87\x01Tc\xFF\xFF\xFF\xFF\x81\x16` \x83\x01Rd\x01\0\0\0\0\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91\x81\x01\x91\x90\x91R\x91Pa\x14\x82\x90PV[a\x08\xD1\x82`\x01\x01\x85a\x16\x83V[`\x04\x82\x01T`\x03\x83\x01T`\x02\x84\x01Ta\x08\xF8\x92`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x92\x91\x16\x90a\x17\nV[\x81T_\x90\x81R` \x81\x81R`@\x80\x83 \x83\x81U`\x01\x80\x82\x01\x80Tc\xFF\xFF\xFF\xFF\x19\x16\x90U`\x02\x82\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`\x03\x82\x01\x85\x90U`\x04\x82\x01\x85\x90U`\x05\x82\x01\x80T\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\x90U`\x06\x90\x91\x01\x80T\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\0\x16\x90U\x88\x84R\x91\x82\x90R\x82 \x82\x81U\x91\x90\x82\x01\x81a\t\xC3\x82\x82a-\xE8V[PPP`\x02\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\x90\x81\x16\x90\x91U_`\x03\x83\x01\x81\x90U`\x04\x83\x01\x80T\x83\x16\x90U`\x05\x83\x01\x80T\x90\x92\x16\x90\x91U`\x06\x90\x91\x01U`@Q\x85\x81R\x7F\xC5w0\x9A\xCDy9\xCC/\x01\xF6\x7F\x07>\x1AT\x82$EL\xDD\xDCy\xB1a\xDB\x17\xB51^\x9F\x0C\x90` \x01`@Q\x80\x91\x03\x90\xA1PPPPPV[``\x80_\x80[`\x02T\x81\x10\x15a\n\x8DW_\x81\x81R`\x01` R`@\x90 `\x03\x01T\x15a\n\x85W\x81a\n\x81\x81a38V[\x92PP[`\x01\x01a\nWV[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xA8Wa\n\xA8a3PV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\n\xE1W\x81` \x01[a\n\xCEa.\"V[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\n\xC6W\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xFEWa\n\xFEa3PV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0B'W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x02T\x81\x10\x15a\x04\xC3W_\x81\x81R`\x01` R`@\x90 `\x03\x01T\x15a\x0C\xA1W`\x01_\x82\x81R` \x01\x90\x81R` \x01_ `@Q\x80`\xE0\x01`@R\x90\x81_\x82\x01T\x81R` \x01`\x01\x82\x01`@Q\x80` \x01`@R\x90\x81_\x82\x01\x80Ta\x0B\x91\x90a4\xBFV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\xBD\x90a4\xBFV[\x80\x15a\x0C\x08W\x80`\x1F\x10a\x0B\xDFWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C\x08V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xEBW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP\x81R`\x02\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16` \x83\x01R`\x03\x83\x01T`@\x83\x01R`\x04\x83\x01T\x81\x16``\x83\x01R`\x05\x83\x01T\x16`\x80\x82\x01R`\x06\x90\x91\x01T`\xA0\x90\x91\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x0CjWa\x0Cja3}V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x0C\x88Wa\x0C\x88a3}V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x0C\x9D\x81a38V[\x92PP[`\x01\x01a\x0B-V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x0C\xFFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FInvalid buying token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05EV[_\x81\x11a\rtW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FBuying amount should be greater `D\x82\x01R\x7Fthan 0\0\0\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\x05EV[`\x02\x80T_\x91\x82a\r\x84\x83a38V[\x91\x90PU\x90P`@Q\x80`\xC0\x01`@R\x80\x86\x806\x03\x81\x01\x90a\r\xA6\x91\x90a8\xE7V[\x81R`\x01`\x01`\xA0\x1B\x03\x85\x16` \x82\x01R`@\x81\x01\x84\x90R``\x01a\r\xD06\x87\x90\x03\x87\x01\x87a9;V[\x81R3` \x80\x83\x01\x91\x90\x91R_`@\x92\x83\x01\x81\x90R\x84\x81R\x80\x82R\x82\x90 \x83Q\x80Q\x82U\x82\x01Q`\x01\x82\x01\x80Tc\xFF\xFF\xFF\xFF\x92\x83\x16c\xFF\xFF\xFF\xFF\x19\x90\x91\x16\x17\x90U\x84\x83\x01Q`\x02\x83\x01\x80T`\x01`\x01`\xA0\x1B\x03\x92\x83\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\x90\x91\x16\x17\x90U\x85\x85\x01Q`\x03\x84\x01U``\x86\x01Q\x80Q`\x04\x85\x01U\x93\x84\x01Q`\x05\x84\x01\x80T\x95\x87\x01Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16d\x01\0\0\0\0\x02\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\x90\x96\x16\x91\x90\x93\x16\x17\x93\x90\x93\x17\x90U`\x80\x84\x01Q`\x06\x90\x91\x01\x80T`\xA0\x90\x95\x01Q\x15\x15t\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\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x95\x16\x91\x90\x92\x16\x17\x92\x90\x92\x17\x90\x91UQ\x81\x90\x7F\xFB-3\x10\xE3\xE7\x95x\xACP|\xDB\xDB2\xE5%\x81\xDB\xC1{\xE0NQ\x97\xD3\xB7\xC5\"s_\xB9\xE4\x90a\x0F?\x90\x88\x90\x87\x90\x87\x90a9\xAEV[`@Q\x80\x91\x03\x90\xA2PPPPPV[_\x81\x81R`\x01` R`@\x90 `\x06\x81\x01Ta\x0Fm\x90aT`\x90a9\xE7V[B\x11a\x0F\xBBW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FRequest still valid\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05EV[`\x05\x81\x01T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x10\x17W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7FSender not the acceptor\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05EV[`\x03\x81\x01T`\x02\x82\x01Ta\x108\x91`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x903\x90a\x17\nV[_\x82\x81R`\x01` \x81\x90R`@\x82 \x82\x81U\x91\x90\x82\x01\x81a\x10Y\x82\x82a-\xE8V[PPP`\x02\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\x90\x81\x16\x90\x91U_`\x03\x83\x01\x81\x90U`\x04\x83\x01\x80T\x83\x16\x90U`\x05\x83\x01\x80T\x90\x92\x16\x90\x91U`\x06\x90\x91\x01U`@Q\x82\x81R\x7F\x9C!jF\x17\xD6\xC0=\xC7\xCB\xD9c!f\xF1\xC5\xC9\xEFA\xF9\xEE\x86\xBF;\x83\xF6q\xC0\x05\x10w\x04\x90` \x01[`@Q\x80\x91\x03\x90\xA1PPV[`\x01` \x81\x81R_\x92\x83R`@\x92\x83\x90 \x80T\x84Q\x92\x83\x01\x90\x94R\x91\x82\x01\x80T\x82\x90\x82\x90a\x11\x12\x90a4\xBFV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x11>\x90a4\xBFV[\x80\x15a\x11\x89W\x80`\x1F\x10a\x11`Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x11\x89V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x11lW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP`\x02\x82\x01T`\x03\x83\x01T`\x04\x84\x01T`\x05\x85\x01T`\x06\x90\x95\x01T\x93\x94`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x94\x92\x93\x91\x82\x16\x92\x91\x16\x90\x87V[_\x81\x81R` \x81\x90R`@\x90 `\x06\x81\x01T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x120W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FSender not the requester\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05EV[`\x06\x81\x01Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x12\xC3W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FOrder has already been accepted,`D\x82\x01R\x7F cannot withdraw\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05EV[_\x82\x81R` \x81\x81R`@\x80\x83 \x83\x81U`\x01\x81\x01\x80Tc\xFF\xFF\xFF\xFF\x19\x16\x90U`\x02\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`\x03\x81\x01\x84\x90U`\x04\x81\x01\x93\x90\x93U`\x05\x83\x01\x80T\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\x90U`\x06\x90\x92\x01\x80T\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\0\x16\x90U\x90Q\x83\x81R\x7F\xB3[?\xE4\xDA\xAFl\xC6n\xB8\xBDA>\x9A\xB5DI\xE7f\xF6\xD4a%\xCCX\xF2UiJ\x0E\x84~\x91\x01a\x10\xD9V[`@Q`\x01`\x01`\xA0\x1B\x03\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x14O\x90\x85\x90\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\x90`\x84\x01[`@\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\x17XV[PPPPV[_a\x14_\x83a\x18=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1B\x08\x91\x90a;qV[`\x80\x84\x01Q\x90\x91Pa\x1B\x1E\x90\x82\x90\x84\x90_a#3V[a\x14OW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`?`$\x82\x01R\x7FCoinbase merkle proof is not val`D\x82\x01R\x7Fid for provided header and hash\0`d\x82\x01R`\x84\x01a\x05EV[_\x83`\x01`\x01`\xA0\x1B\x03\x16c\x117d\xBE`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1B\xCDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1B\xF1\x91\x90a;qV[\x90P_\x84`\x01`\x01`\xA0\x1B\x03\x16c+\x97\xBE$`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1C0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1CT\x91\x90a;qV[\x90P_\x80a\x1Cia\x1Cd\x86a#eV[a#pV[\x90P\x83\x81\x03a\x1CzW\x83\x91Pa\x1C\xF7V[\x82\x81\x03a\x1C\x89W\x82\x91Pa\x1C\xF7V[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`%`$\x82\x01R\x7FNot at current or previous diffi`D\x82\x01R\x7Fculty\0\0\0\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\x05EV[_a\x1D\x01\x86a#\x97V[\x90P_\x19\x81\x03a\x1DyW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`#`$\x82\x01R\x7FInvalid length of the headers ch`D\x82\x01R\x7Fain\0\0\0\0\0\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\x05EV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81\x03a\x1D\xE8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FInvalid headers chain\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05EV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFD\x81\x03a\x1EWW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FInsufficient work in a header\0\0\0`D\x82\x01R`d\x01a\x05EV[a\x1Ea\x87\x84a;\x88V[\x81\x10\x15a\x1E\xD6W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FInsufficient accumulated difficu`D\x82\x01R\x7Flty in header chain\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05EV[PPPPPPPPV[__a\x1E\xEC\x83_a%\xBBV[\x91P\x91P\x91P\x91V[`@\x80Q` \x80\x82R\x81\x83\x01\x90\x92R_\x91\x82\x91\x90` \x82\x01\x81\x806\x837\x01\x90PP\x90P_[` \x81\x10\x15a\x1F\x97W\x83\x81` \x81\x10a\x1F5Wa\x1F5a3}V[\x1A`\xF8\x1B\x82`\x01a\x1FG\x84` a;\x9FV[a\x1FQ\x91\x90a;\x9FV[\x81Q\x81\x10a\x1FaWa\x1Faa3}V[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SP`\x01\x01a\x1F\x1AV[P` \x01Q\x92\x91PPV[_a\x1F\xB0\x83\x83\x01` \x01Q\x90V[\x93\x92PPPV[_a\x1F\xB0a\x1F\xC6\x83` a9\xE7V[\x84\x90a\x1F\xA2V[___a\x1F\xDA\x85\x85a'2V[\x90\x92P\x90P`\x01\x82\x01a\x1F\xF2W_\x19\x92PPPa\x07$V[\x80a\x1F\xFE\x83`%a9\xE7V[a \x08\x91\x90a9\xE7V[a \x13\x90`\x04a9\xE7V[\x95\x94PPPPPV[`@\x80Q``\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x82\x84\x01\x82\x90R\x83Q\x80\x85\x01\x90\x94R\x81\x84R\x83\x01R\x90a P\x84a\x1E\xE0V[` \x83\x01R\x80\x82R\x81a b\x82a38V[\x90RP_\x80[\x82` \x01Q\x81\x10\x15a!dW\x82Q_\x90a \x83\x90\x88\x90a'uV[\x84Q\x90\x91P_\x90a \x95\x90\x89\x90a'\xD0V[\x90P_a \xA3`\x08\x84a;\x9FV[\x86Q\x90\x91P_\x90a \xB5\x90`\x08a9\xE7V[\x8A\x81\x01` \x01\x83\x90 \x90\x91P\x80\x8A\x03a \xEFW`\x01\x96P\x83\x89_\x01\x81\x81Qa \xDD\x91\x90a;\xB2V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RPa!?V[_a \xFD\x8C\x8A_\x01Qa(FV[\x90P`\x01`\x01`\xA0\x1B\x03\x81\x16\x15a!\x1EW`\x01`\x01`\xA0\x1B\x03\x81\x16` \x8B\x01R[_a!,\x8D\x8B_\x01Qa)&V[\x90P\x80\x15a!a+/V[``\x91P[P\x91P\x91Pa+?\x82\x82\x86a-eV[\x97\x96PPPPPPPV[_` \x84Qa+Y\x91\x90a;\xFFV[\x15a+eWP_a\x14zV[\x83Q_\x03a+tWP_a\x14zV[\x81\x85_[\x86Q\x81\x10\x15a+\xE2Wa+\x8C`\x02\x84a;\xFFV[`\x01\x03a+\xB0Wa+\xA9a+\xA3\x88\x83\x01` \x01Q\x90V[\x83a-\x9EV[\x91Pa+\xC9V[a+\xC6\x82a+\xC1\x89\x84\x01` \x01Q\x90V[a-\x9EV[\x91P[`\x01\x92\x90\x92\x1C\x91a+\xDB` \x82a9\xE7V[\x90Pa+xV[P\x90\x93\x14\x95\x94PPPPPV[_\x80a,\x06a+\xFF\x84`Ha9\xE7V[\x85\x90a\x1F\xA2V[`\xE8\x1C\x90P_\x84a,\x18\x85`Ka9\xE7V[\x81Q\x81\x10a,(Wa,(a3}V[\x01` \x01Q`\xF8\x1C\x90P_a,Z\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a,m`\x03\x84a<+V[`\xFF\x16\x90Pa,~\x81a\x01\0a='V[a+?\x90\x83a;\x88V[_a\x1F\xB0\x82\x84a=2V[_\x80a,\x9F\x85\x85a-\xA9V[\x90P\x82\x81\x14a,\xB1W_\x91PPa\x1F\xB0V[P`\x01\x94\x93PPPPV[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x82\x82\x81Q\x81\x10a,\xF4Wa,\xF4a3}V[\x01` \x01Q`\xF8\x1C`\xFF\x03a-\x0BWP`\x08a\x07$V[\x82\x82\x81Q\x81\x10a-\x1DWa-\x1Da3}V[\x01` \x01Q`\xF8\x1C`\xFE\x03a-4WP`\x04a\x07$V[\x82\x82\x81Q\x81\x10a-FWa-Fa3}V[\x01` \x01Q`\xF8\x1C`\xFD\x03a-]WP`\x02a\x07$V[P_\x92\x91PPV[``\x83\x15a-tWP\x81a\x1F\xB0V[\x82Q\x15a-\x84W\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x05E\x91\x90a=EV[_a\x1F\xB0\x83\x83a-\xC1V[_a\x1F\xB0a-\xB8\x83`\x04a9\xE7V[\x84\x01` \x01Q\x90V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[P\x80Ta-\xF4\x90a4\xBFV[_\x82U\x80`\x1F\x10a.\x03WPPV[`\x1F\x01` \x90\x04\x90_R` _ \x90\x81\x01\x90a.\x1F\x91\x90a.qV[PV[`@Q\x80`\xE0\x01`@R\x80_\x81R` \x01a.I`@Q\x80` \x01`@R\x80``\x81RP\x90V[\x81R_` \x82\x01\x81\x90R`@\x82\x01\x81\x90R``\x82\x01\x81\x90R`\x80\x82\x01\x81\x90R`\xA0\x90\x91\x01R\x90V[[\x80\x82\x11\x15a.\x85W_\x81U`\x01\x01a.rV[P\x90V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a.\xB9W\x81Q\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a.\x9BV[P\x93\x94\x93PPPPV[`@\x80\x82R\x83Q\x90\x82\x01\x81\x90R_\x90` \x85\x01\x90``\x84\x01\x90\x83[\x81\x81\x10\x15a/\x8CW\x83Qa/\x03\x84\x82Q\x80Q\x82R` \x90\x81\x01Qc\xFF\xFF\xFF\xFF\x16\x91\x01RV[`\x01`\x01`\xA0\x1B\x03` \x82\x01Q\x16`@\x85\x01R`@\x81\x01Q``\x85\x01R``\x81\x01Qa/V`\x80\x86\x01\x82\x80Q\x82R` \x80\x82\x01Qc\xFF\xFF\xFF\xFF\x16\x90\x83\x01R`@\x90\x81\x01Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91\x01RV[P`\x80\x81\x01Q`\x01`\x01`\xA0\x1B\x03\x16`\xE0\x85\x01R`\xA0\x01Q\x15\x15a\x01\0\x84\x01R` \x93\x90\x93\x01\x92a\x01 \x90\x92\x01\x91`\x01\x01a.\xDEV[PP\x83\x81\x03` \x85\x01Ra/\xA0\x81\x86a.\x89V[\x96\x95PPPPPPV[__`@\x83\x85\x03\x12\x15a/\xBBW__\xFD[\x825\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a/\xD8W__\xFD[\x83\x01` \x81\x86\x03\x12\x15a/\xE9W__\xFD[\x80\x91PP\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a0\x04W__\xFD[P5\x91\x90PV[\x86Q\x81R` \x80\x88\x01Qc\xFF\xFF\xFF\xFF\x16\x90\x82\x01Ra\x01 \x81\x01`\x01`\x01`\xA0\x1B\x03\x87\x16`@\x83\x01R\x85``\x83\x01Ra0j`\x80\x83\x01\x86\x80Q\x82R` \x80\x82\x01Qc\xFF\xFF\xFF\xFF\x16\x90\x83\x01R`@\x90\x81\x01Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91\x01RV[`\x01`\x01`\xA0\x1B\x03\x84\x16`\xE0\x83\x01R\x82\x15\x15a\x01\0\x83\x01R\x97\x96PPPPPPPV[___``\x84\x86\x03\x12\x15a0\x9FW__\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a0\xBCW__\xFD[\x84\x01`\x80\x81\x87\x03\x12\x15a0\xCDW__\xFD[\x91P`@\x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a0\xE8W__\xFD[\x84\x01`\xA0\x81\x87\x03\x12\x15a0\xF9W__\xFD[\x80\x91PP\x92P\x92P\x92V[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_\x81Q` \x84Ra\x14z` \x85\x01\x82a1\x04V[_`@\x82\x01`@\x83R\x80\x85Q\x80\x83R``\x85\x01\x91P``\x81`\x05\x1B\x86\x01\x01\x92P` \x87\x01_[\x82\x81\x10\x15a2%W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x87\x86\x03\x01\x84R\x81Q\x80Q\x86R` \x81\x01Q`\xE0` \x88\x01Ra1\xBA`\xE0\x88\x01\x82a12V[\x90P`\x01`\x01`\xA0\x1B\x03`@\x83\x01Q\x16`@\x88\x01R``\x82\x01Q``\x88\x01R`\x01`\x01`\xA0\x1B\x03`\x80\x83\x01Q\x16`\x80\x88\x01R`\x01`\x01`\xA0\x1B\x03`\xA0\x83\x01Q\x16`\xA0\x88\x01R`\xC0\x82\x01Q`\xC0\x88\x01R\x80\x96PPP` \x82\x01\x91P` \x84\x01\x93P`\x01\x81\x01\x90Pa1lV[PPPP\x82\x81\x03` \x84\x01Ra \x13\x81\x85a.\x89V[____\x84\x86\x03`\xE0\x81\x12\x15a2OW__\xFD[`@\x81\x12\x15a2\\W__\xFD[\x85\x94P``\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x82\x01\x12\x15a2\x8EW__\xFD[P`@\x85\x01\x92P`\xA0\x85\x015`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a2\xAEW__\xFD[\x93\x96\x92\x95P\x92\x93`\xC0\x015\x92PPV[\x87\x81R`\xE0` \x82\x01R_a2\xD6`\xE0\x83\x01\x89a12V[`\x01`\x01`\xA0\x1B\x03\x97\x88\x16`@\x84\x01R``\x83\x01\x96\x90\x96RP\x92\x85\x16`\x80\x84\x01R\x93\x16`\xA0\x82\x01R`\xC0\x01\x91\x90\x91R\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[__\x19\x82\x03a3IWa3Ia3\x0BV[P`\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`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`\xA0\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a3\xCDWa3\xCDa3PV[`@R\x90V[_\x82`\x1F\x83\x01\x12a3\xE2W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a3\xFCWa3\xFCa3PV[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a4+Wa4+a3PV[`@R\x81\x81R\x83\x82\x01` \x01\x85\x10\x15a4BW__\xFD[\x81` \x85\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[_` \x826\x03\x12\x15a4nW__\xFD[`@Q` \x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a4\x91Wa4\x91a3PV[`@R\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a4\xAAW__\xFD[a4\xB66\x82\x86\x01a3\xD3V[\x82RP\x92\x91PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a4\xD3W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a5\nW\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[P\x91\x90PV[`\x1F\x82\x11\x15a\x17SW\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a55WP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a5TW_\x81U`\x01\x01a5AV[PPPPPV[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a5uWa5ua3PV[a5\x89\x81a5\x83\x84Ta4\xBFV[\x84a5\x10V[` `\x1F\x82\x11`\x01\x81\x14a5\xBBW_\x83\x15a5\xA4WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua5TV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a5\xEAW\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a5\xCAV[P\x84\x82\x10\x15a6\x07W\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[\x81\x83R\x81\x81` \x85\x017P_` \x82\x84\x01\x01R_` `\x1F\x19`\x1F\x84\x01\x16\x84\x01\x01\x90P\x92\x91PPV[``\x81R_\x845\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x866\x03\x01\x81\x12a6uW__\xFD[\x85\x01` \x81\x01\x905g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a6\x91W__\xFD[\x806\x03\x82\x13\x15a6\x9FW__\xFD[` ``\x85\x01Ra6\xB4`\x80\x85\x01\x82\x84a6\x16V[`\x01`\x01`\xA0\x1B\x03\x96\x90\x96\x16` \x85\x01RPPP`@\x01R\x91\x90PV[__\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\x12a7\x04W__\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a7\x1EW__\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a'+W__\xFD[` \x81R_a\x14z` \x83\x01\x84\x86a6\x16V[\x805\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\x14a7tW__\xFD[\x91\x90PV[_`\x80\x826\x03\x12\x15a7\x89W__\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a7\xACWa7\xACa3PV[`@Ra7\xB8\x83a7EV[\x81R` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a7\xD3W__\xFD[a7\xDF6\x82\x86\x01a3\xD3V[` \x83\x01RP`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a7\xFEW__\xFD[a8\n6\x82\x86\x01a3\xD3V[`@\x83\x01RPa8\x1C``\x84\x01a7EV[``\x82\x01R\x92\x91PPV[_`\xA0\x826\x03\x12\x15a87W__\xFD[a8?a3\xAAV[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a8UW__\xFD[a8a6\x82\x86\x01a3\xD3V[\x82RP` \x83\x81\x015\x90\x82\x01R`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a8\x87W__\xFD[a8\x936\x82\x86\x01a3\xD3V[`@\x83\x01RP``\x83\x81\x015\x90\x82\x01R`\x80\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a8\xBCW__\xFD[a8\xC86\x82\x86\x01a3\xD3V[`\x80\x83\x01RP\x92\x91PPV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a7tW__\xFD[_`@\x82\x84\x03\x12\x80\x15a8\xF8W__\xFD[P`@\x80Q\x90\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a9\x1CWa9\x1Ca3PV[`@R\x825\x81Ra9/` \x84\x01a8\xD4V[` \x82\x01R\x93\x92PPPV[_``\x82\x84\x03\x12\x80\x15a9LW__\xFD[P`@Q``\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a9pWa9pa3PV[`@R\x825\x81Ra9\x83` \x84\x01a8\xD4V[` \x82\x01R`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a9\xA2W__\xFD[`@\x82\x01R\x93\x92PPPV[\x835\x81R`\x80\x81\x01c\xFF\xFF\xFF\xFFa9\xC7` \x87\x01a8\xD4V[\x16` \x83\x01R`\x01`\x01`\xA0\x1B\x03\x93\x90\x93\x16`@\x82\x01R``\x01R\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x07$Wa\x07$a3\x0BV[\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\x83`\xF8\x1B\x16\x81R__\x83Ta:/\x81a4\xBFV[`\x01\x82\x16\x80\x15a:FW`\x01\x81\x14a:\x7FWa:\xB5V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x83\x16`\x01\x87\x01R`\x01\x82\x15\x15\x83\x02\x87\x01\x01\x93Pa:\xB5V[\x86_R` _ _[\x83\x81\x10\x15a:\xAAW\x81T`\x01\x82\x8A\x01\x01R`\x01\x82\x01\x91P` \x81\x01\x90Pa:\x88V[PP`\x01\x82\x87\x01\x01\x93P[P\x91\x96\x95PPPPPPV[_` \x82\x84\x03\x12\x15a:\xD1W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x1F\xB0W__\xFD[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[\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\x85\x16\x81R_a;3a;-`\x04\x84\x01\x87a:\xE0V[\x85a:\xE0V[\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\x93\x90\x93\x16\x83RPP`\x04\x01\x93\x92PPPV[_a\x1F\xB0\x82\x84a:\xE0V[_` \x82\x84\x03\x12\x15a;\x81W__\xFD[PQ\x91\x90PV[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x07$Wa\x07$a3\x0BV[\x81\x81\x03\x81\x81\x11\x15a\x07$Wa\x07$a3\x0BV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x07$Wa\x07$a3\x0BV[\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<\rWa<\ra;\xD2V[P\x06\x90V[`\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x07$Wa\x07$a3\x0BV[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x07$Wa\x07$a3\x0BV[`\x01\x81[`\x01\x84\x11\x15a<\x7FW\x80\x85\x04\x81\x11\x15a=_\xFD[PPPPa\x08>`\x04T\x85a\x08!\x90a7yV[a\x08*\x86a8'V[`\x03T`\x01`\x01`\xA0\x1B\x03\x16\x92\x91\x90a\x14UV[Pa\x08\xC4a\x08O` \x86\x01\x86a6\xD1V[\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\x91RPP`@\x80Q``\x81\x01\x82R`\x04\x87\x01T\x81R`\x05\x87\x01Tc\xFF\xFF\xFF\xFF\x81\x16` \x83\x01Rd\x01\0\0\0\0\x90\x04g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91\x81\x01\x91\x90\x91R\x91Pa\x14\x82\x90PV[a\x08\xD1\x82`\x01\x01\x85a\x16\x83V[`\x04\x82\x01T`\x03\x83\x01T`\x02\x84\x01Ta\x08\xF8\x92`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x92\x91\x16\x90a\x17\nV[\x81T_\x90\x81R` \x81\x81R`@\x80\x83 \x83\x81U`\x01\x80\x82\x01\x80Tc\xFF\xFF\xFF\xFF\x19\x16\x90U`\x02\x82\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`\x03\x82\x01\x85\x90U`\x04\x82\x01\x85\x90U`\x05\x82\x01\x80T\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\x90U`\x06\x90\x91\x01\x80T\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\0\x16\x90U\x88\x84R\x91\x82\x90R\x82 \x82\x81U\x91\x90\x82\x01\x81a\t\xC3\x82\x82a-\xE8V[PPP`\x02\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\x90\x81\x16\x90\x91U_`\x03\x83\x01\x81\x90U`\x04\x83\x01\x80T\x83\x16\x90U`\x05\x83\x01\x80T\x90\x92\x16\x90\x91U`\x06\x90\x91\x01U`@Q\x85\x81R\x7F\xC5w0\x9A\xCDy9\xCC/\x01\xF6\x7F\x07>\x1AT\x82$EL\xDD\xDCy\xB1a\xDB\x17\xB51^\x9F\x0C\x90` \x01`@Q\x80\x91\x03\x90\xA1PPPPPV[``\x80_\x80[`\x02T\x81\x10\x15a\n\x8DW_\x81\x81R`\x01` R`@\x90 `\x03\x01T\x15a\n\x85W\x81a\n\x81\x81a38V[\x92PP[`\x01\x01a\nWV[P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xA8Wa\n\xA8a3PV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\n\xE1W\x81` \x01[a\n\xCEa.\"V[\x81R` \x01\x90`\x01\x90\x03\x90\x81a\n\xC6W\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xFEWa\n\xFEa3PV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x0B'W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x80[`\x02T\x81\x10\x15a\x04\xC3W_\x81\x81R`\x01` R`@\x90 `\x03\x01T\x15a\x0C\xA1W`\x01_\x82\x81R` \x01\x90\x81R` \x01_ `@Q\x80`\xE0\x01`@R\x90\x81_\x82\x01T\x81R` \x01`\x01\x82\x01`@Q\x80` \x01`@R\x90\x81_\x82\x01\x80Ta\x0B\x91\x90a4\xBFV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\xBD\x90a4\xBFV[\x80\x15a\x0C\x08W\x80`\x1F\x10a\x0B\xDFWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0C\x08V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xEBW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP\x81R`\x02\x82\x01T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16` \x83\x01R`\x03\x83\x01T`@\x83\x01R`\x04\x83\x01T\x81\x16``\x83\x01R`\x05\x83\x01T\x16`\x80\x82\x01R`\x06\x90\x91\x01T`\xA0\x90\x91\x01R\x84Q\x85\x90\x84\x90\x81\x10a\x0CjWa\x0Cja3}V[` \x02` \x01\x01\x81\x90RP\x80\x83\x83\x81Q\x81\x10a\x0C\x88Wa\x0C\x88a3}V[` \x90\x81\x02\x91\x90\x91\x01\x01R\x81a\x0C\x9D\x81a38V[\x92PP[`\x01\x01a\x0B-V[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x0C\xFFW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FInvalid buying token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05EV[_\x81\x11a\rtW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FBuying amount should be greater `D\x82\x01R\x7Fthan 0\0\0\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\x05EV[`\x02\x80T_\x91\x82a\r\x84\x83a38V[\x91\x90PU\x90P`@Q\x80`\xC0\x01`@R\x80\x86\x806\x03\x81\x01\x90a\r\xA6\x91\x90a8\xE7V[\x81R`\x01`\x01`\xA0\x1B\x03\x85\x16` \x82\x01R`@\x81\x01\x84\x90R``\x01a\r\xD06\x87\x90\x03\x87\x01\x87a9;V[\x81R3` \x80\x83\x01\x91\x90\x91R_`@\x92\x83\x01\x81\x90R\x84\x81R\x80\x82R\x82\x90 \x83Q\x80Q\x82U\x82\x01Q`\x01\x82\x01\x80Tc\xFF\xFF\xFF\xFF\x92\x83\x16c\xFF\xFF\xFF\xFF\x19\x90\x91\x16\x17\x90U\x84\x83\x01Q`\x02\x83\x01\x80T`\x01`\x01`\xA0\x1B\x03\x92\x83\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\x90\x91\x16\x17\x90U\x85\x85\x01Q`\x03\x84\x01U``\x86\x01Q\x80Q`\x04\x85\x01U\x93\x84\x01Q`\x05\x84\x01\x80T\x95\x87\x01Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16d\x01\0\0\0\0\x02\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\x90\x96\x16\x91\x90\x93\x16\x17\x93\x90\x93\x17\x90U`\x80\x84\x01Q`\x06\x90\x91\x01\x80T`\xA0\x90\x95\x01Q\x15\x15t\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\xFF\xFF\xFF\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x95\x16\x91\x90\x92\x16\x17\x92\x90\x92\x17\x90\x91UQ\x81\x90\x7F\xFB-3\x10\xE3\xE7\x95x\xACP|\xDB\xDB2\xE5%\x81\xDB\xC1{\xE0NQ\x97\xD3\xB7\xC5\"s_\xB9\xE4\x90a\x0F?\x90\x88\x90\x87\x90\x87\x90a9\xAEV[`@Q\x80\x91\x03\x90\xA2PPPPPV[_\x81\x81R`\x01` R`@\x90 `\x06\x81\x01Ta\x0Fm\x90aT`\x90a9\xE7V[B\x11a\x0F\xBBW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x13`$\x82\x01R\x7FRequest still valid\0\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05EV[`\x05\x81\x01T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x10\x17W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7FSender not the acceptor\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05EV[`\x03\x81\x01T`\x02\x82\x01Ta\x108\x91`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x903\x90a\x17\nV[_\x82\x81R`\x01` \x81\x90R`@\x82 \x82\x81U\x91\x90\x82\x01\x81a\x10Y\x82\x82a-\xE8V[PPP`\x02\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\x90\x81\x16\x90\x91U_`\x03\x83\x01\x81\x90U`\x04\x83\x01\x80T\x83\x16\x90U`\x05\x83\x01\x80T\x90\x92\x16\x90\x91U`\x06\x90\x91\x01U`@Q\x82\x81R\x7F\x9C!jF\x17\xD6\xC0=\xC7\xCB\xD9c!f\xF1\xC5\xC9\xEFA\xF9\xEE\x86\xBF;\x83\xF6q\xC0\x05\x10w\x04\x90` \x01[`@Q\x80\x91\x03\x90\xA1PPV[`\x01` \x81\x81R_\x92\x83R`@\x92\x83\x90 \x80T\x84Q\x92\x83\x01\x90\x94R\x91\x82\x01\x80T\x82\x90\x82\x90a\x11\x12\x90a4\xBFV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x11>\x90a4\xBFV[\x80\x15a\x11\x89W\x80`\x1F\x10a\x11`Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x11\x89V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x11lW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPP\x91\x90\x92RPPP`\x02\x82\x01T`\x03\x83\x01T`\x04\x84\x01T`\x05\x85\x01T`\x06\x90\x95\x01T\x93\x94`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x94\x92\x93\x91\x82\x16\x92\x91\x16\x90\x87V[_\x81\x81R` \x81\x90R`@\x90 `\x06\x81\x01T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x120W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x18`$\x82\x01R\x7FSender not the requester\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05EV[`\x06\x81\x01Tt\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x90\x04`\xFF\x16\x15a\x12\xC3W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`0`$\x82\x01R\x7FOrder has already been accepted,`D\x82\x01R\x7F cannot withdraw\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05EV[_\x82\x81R` \x81\x81R`@\x80\x83 \x83\x81U`\x01\x81\x01\x80Tc\xFF\xFF\xFF\xFF\x19\x16\x90U`\x02\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`\x03\x81\x01\x84\x90U`\x04\x81\x01\x93\x90\x93U`\x05\x83\x01\x80T\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\x90U`\x06\x90\x92\x01\x80T\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\0\x16\x90U\x90Q\x83\x81R\x7F\xB3[?\xE4\xDA\xAFl\xC6n\xB8\xBDA>\x9A\xB5DI\xE7f\xF6\xD4a%\xCCX\xF2UiJ\x0E\x84~\x91\x01a\x10\xD9V[`@Q`\x01`\x01`\xA0\x1B\x03\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x14O\x90\x85\x90\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\x90`\x84\x01[`@\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\x17XV[PPPPV[_a\x14_\x83a\x18=_\xFD[PPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1B\x08\x91\x90a;qV[`\x80\x84\x01Q\x90\x91Pa\x1B\x1E\x90\x82\x90\x84\x90_a#3V[a\x14OW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`?`$\x82\x01R\x7FCoinbase merkle proof is not val`D\x82\x01R\x7Fid for provided header and hash\0`d\x82\x01R`\x84\x01a\x05EV[_\x83`\x01`\x01`\xA0\x1B\x03\x16c\x117d\xBE`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1B\xCDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1B\xF1\x91\x90a;qV[\x90P_\x84`\x01`\x01`\xA0\x1B\x03\x16c+\x97\xBE$`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1C0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1CT\x91\x90a;qV[\x90P_\x80a\x1Cia\x1Cd\x86a#eV[a#pV[\x90P\x83\x81\x03a\x1CzW\x83\x91Pa\x1C\xF7V[\x82\x81\x03a\x1C\x89W\x82\x91Pa\x1C\xF7V[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`%`$\x82\x01R\x7FNot at current or previous diffi`D\x82\x01R\x7Fculty\0\0\0\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\x05EV[_a\x1D\x01\x86a#\x97V[\x90P_\x19\x81\x03a\x1DyW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`#`$\x82\x01R\x7FInvalid length of the headers ch`D\x82\x01R\x7Fain\0\0\0\0\0\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\x05EV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81\x03a\x1D\xE8W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x15`$\x82\x01R\x7FInvalid headers chain\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x05EV[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFD\x81\x03a\x1EWW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FInsufficient work in a header\0\0\0`D\x82\x01R`d\x01a\x05EV[a\x1Ea\x87\x84a;\x88V[\x81\x10\x15a\x1E\xD6W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`3`$\x82\x01R\x7FInsufficient accumulated difficu`D\x82\x01R\x7Flty in header chain\0\0\0\0\0\0\0\0\0\0\0\0\0`d\x82\x01R`\x84\x01a\x05EV[PPPPPPPPV[__a\x1E\xEC\x83_a%\xBBV[\x91P\x91P\x91P\x91V[`@\x80Q` \x80\x82R\x81\x83\x01\x90\x92R_\x91\x82\x91\x90` \x82\x01\x81\x806\x837\x01\x90PP\x90P_[` \x81\x10\x15a\x1F\x97W\x83\x81` \x81\x10a\x1F5Wa\x1F5a3}V[\x1A`\xF8\x1B\x82`\x01a\x1FG\x84` a;\x9FV[a\x1FQ\x91\x90a;\x9FV[\x81Q\x81\x10a\x1FaWa\x1Faa3}V[` \x01\x01\x90~\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x81_\x1A\x90SP`\x01\x01a\x1F\x1AV[P` \x01Q\x92\x91PPV[_a\x1F\xB0\x83\x83\x01` \x01Q\x90V[\x93\x92PPPV[_a\x1F\xB0a\x1F\xC6\x83` a9\xE7V[\x84\x90a\x1F\xA2V[___a\x1F\xDA\x85\x85a'2V[\x90\x92P\x90P`\x01\x82\x01a\x1F\xF2W_\x19\x92PPPa\x07$V[\x80a\x1F\xFE\x83`%a9\xE7V[a \x08\x91\x90a9\xE7V[a \x13\x90`\x04a9\xE7V[\x95\x94PPPPPV[`@\x80Q``\x81\x01\x82R_\x80\x82R` \x80\x83\x01\x82\x90R\x82\x84\x01\x82\x90R\x83Q\x80\x85\x01\x90\x94R\x81\x84R\x83\x01R\x90a P\x84a\x1E\xE0V[` \x83\x01R\x80\x82R\x81a b\x82a38V[\x90RP_\x80[\x82` \x01Q\x81\x10\x15a!dW\x82Q_\x90a \x83\x90\x88\x90a'uV[\x84Q\x90\x91P_\x90a \x95\x90\x89\x90a'\xD0V[\x90P_a \xA3`\x08\x84a;\x9FV[\x86Q\x90\x91P_\x90a \xB5\x90`\x08a9\xE7V[\x8A\x81\x01` \x01\x83\x90 \x90\x91P\x80\x8A\x03a \xEFW`\x01\x96P\x83\x89_\x01\x81\x81Qa \xDD\x91\x90a;\xB2V[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x90RPa!?V[_a \xFD\x8C\x8A_\x01Qa(FV[\x90P`\x01`\x01`\xA0\x1B\x03\x81\x16\x15a!\x1EW`\x01`\x01`\xA0\x1B\x03\x81\x16` \x8B\x01R[_a!,\x8D\x8B_\x01Qa)&V[\x90P\x80\x15a!a+/V[``\x91P[P\x91P\x91Pa+?\x82\x82\x86a-eV[\x97\x96PPPPPPPV[_` \x84Qa+Y\x91\x90a;\xFFV[\x15a+eWP_a\x14zV[\x83Q_\x03a+tWP_a\x14zV[\x81\x85_[\x86Q\x81\x10\x15a+\xE2Wa+\x8C`\x02\x84a;\xFFV[`\x01\x03a+\xB0Wa+\xA9a+\xA3\x88\x83\x01` \x01Q\x90V[\x83a-\x9EV[\x91Pa+\xC9V[a+\xC6\x82a+\xC1\x89\x84\x01` \x01Q\x90V[a-\x9EV[\x91P[`\x01\x92\x90\x92\x1C\x91a+\xDB` \x82a9\xE7V[\x90Pa+xV[P\x90\x93\x14\x95\x94PPPPPV[_\x80a,\x06a+\xFF\x84`Ha9\xE7V[\x85\x90a\x1F\xA2V[`\xE8\x1C\x90P_\x84a,\x18\x85`Ka9\xE7V[\x81Q\x81\x10a,(Wa,(a3}V[\x01` \x01Q`\xF8\x1C\x90P_a,Z\x83_`\x10\x82b\xFF\xFF\xFF\x16\x90\x1C\x82a\xFF\0\x16`\x10\x84b\xFF\xFF\xFF\x16\x90\x1B\x17\x17\x90P\x91\x90PV[b\xFF\xFF\xFF\x16\x90P_a,m`\x03\x84a<+V[`\xFF\x16\x90Pa,~\x81a\x01\0a='V[a+?\x90\x83a;\x88V[_a\x1F\xB0\x82\x84a=2V[_\x80a,\x9F\x85\x85a-\xA9V[\x90P\x82\x81\x14a,\xB1W_\x91PPa\x1F\xB0V[P`\x01\x94\x93PPPPV[_` _\x83\x85` \x01\x87\x01`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x93\x92PPPV[_\x82\x82\x81Q\x81\x10a,\xF4Wa,\xF4a3}V[\x01` \x01Q`\xF8\x1C`\xFF\x03a-\x0BWP`\x08a\x07$V[\x82\x82\x81Q\x81\x10a-\x1DWa-\x1Da3}V[\x01` \x01Q`\xF8\x1C`\xFE\x03a-4WP`\x04a\x07$V[\x82\x82\x81Q\x81\x10a-FWa-Fa3}V[\x01` \x01Q`\xF8\x1C`\xFD\x03a-]WP`\x02a\x07$V[P_\x92\x91PPV[``\x83\x15a-tWP\x81a\x1F\xB0V[\x82Q\x15a-\x84W\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x05E\x91\x90a=EV[_a\x1F\xB0\x83\x83a-\xC1V[_a\x1F\xB0a-\xB8\x83`\x04a9\xE7V[\x84\x01` \x01Q\x90V[_\x82_R\x81` R` _`@_`\x02Z\xFAP` _` _`\x02Z\xFAPP_Q\x92\x91PPV[P\x80Ta-\xF4\x90a4\xBFV[_\x82U\x80`\x1F\x10a.\x03WPPV[`\x1F\x01` \x90\x04\x90_R` _ \x90\x81\x01\x90a.\x1F\x91\x90a.qV[PV[`@Q\x80`\xE0\x01`@R\x80_\x81R` \x01a.I`@Q\x80` \x01`@R\x80``\x81RP\x90V[\x81R_` \x82\x01\x81\x90R`@\x82\x01\x81\x90R``\x82\x01\x81\x90R`\x80\x82\x01\x81\x90R`\xA0\x90\x91\x01R\x90V[[\x80\x82\x11\x15a.\x85W_\x81U`\x01\x01a.rV[P\x90V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a.\xB9W\x81Q\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a.\x9BV[P\x93\x94\x93PPPPV[`@\x80\x82R\x83Q\x90\x82\x01\x81\x90R_\x90` \x85\x01\x90``\x84\x01\x90\x83[\x81\x81\x10\x15a/\x8CW\x83Qa/\x03\x84\x82Q\x80Q\x82R` \x90\x81\x01Qc\xFF\xFF\xFF\xFF\x16\x91\x01RV[`\x01`\x01`\xA0\x1B\x03` \x82\x01Q\x16`@\x85\x01R`@\x81\x01Q``\x85\x01R``\x81\x01Qa/V`\x80\x86\x01\x82\x80Q\x82R` \x80\x82\x01Qc\xFF\xFF\xFF\xFF\x16\x90\x83\x01R`@\x90\x81\x01Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91\x01RV[P`\x80\x81\x01Q`\x01`\x01`\xA0\x1B\x03\x16`\xE0\x85\x01R`\xA0\x01Q\x15\x15a\x01\0\x84\x01R` \x93\x90\x93\x01\x92a\x01 \x90\x92\x01\x91`\x01\x01a.\xDEV[PP\x83\x81\x03` \x85\x01Ra/\xA0\x81\x86a.\x89V[\x96\x95PPPPPPV[__`@\x83\x85\x03\x12\x15a/\xBBW__\xFD[\x825\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a/\xD8W__\xFD[\x83\x01` \x81\x86\x03\x12\x15a/\xE9W__\xFD[\x80\x91PP\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a0\x04W__\xFD[P5\x91\x90PV[\x86Q\x81R` \x80\x88\x01Qc\xFF\xFF\xFF\xFF\x16\x90\x82\x01Ra\x01 \x81\x01`\x01`\x01`\xA0\x1B\x03\x87\x16`@\x83\x01R\x85``\x83\x01Ra0j`\x80\x83\x01\x86\x80Q\x82R` \x80\x82\x01Qc\xFF\xFF\xFF\xFF\x16\x90\x83\x01R`@\x90\x81\x01Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x91\x01RV[`\x01`\x01`\xA0\x1B\x03\x84\x16`\xE0\x83\x01R\x82\x15\x15a\x01\0\x83\x01R\x97\x96PPPPPPPV[___``\x84\x86\x03\x12\x15a0\x9FW__\xFD[\x835\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a0\xBCW__\xFD[\x84\x01`\x80\x81\x87\x03\x12\x15a0\xCDW__\xFD[\x91P`@\x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a0\xE8W__\xFD[\x84\x01`\xA0\x81\x87\x03\x12\x15a0\xF9W__\xFD[\x80\x91PP\x92P\x92P\x92V[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_\x81Q` \x84Ra\x14z` \x85\x01\x82a1\x04V[_`@\x82\x01`@\x83R\x80\x85Q\x80\x83R``\x85\x01\x91P``\x81`\x05\x1B\x86\x01\x01\x92P` \x87\x01_[\x82\x81\x10\x15a2%W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x87\x86\x03\x01\x84R\x81Q\x80Q\x86R` \x81\x01Q`\xE0` \x88\x01Ra1\xBA`\xE0\x88\x01\x82a12V[\x90P`\x01`\x01`\xA0\x1B\x03`@\x83\x01Q\x16`@\x88\x01R``\x82\x01Q``\x88\x01R`\x01`\x01`\xA0\x1B\x03`\x80\x83\x01Q\x16`\x80\x88\x01R`\x01`\x01`\xA0\x1B\x03`\xA0\x83\x01Q\x16`\xA0\x88\x01R`\xC0\x82\x01Q`\xC0\x88\x01R\x80\x96PPP` \x82\x01\x91P` \x84\x01\x93P`\x01\x81\x01\x90Pa1lV[PPPP\x82\x81\x03` \x84\x01Ra \x13\x81\x85a.\x89V[____\x84\x86\x03`\xE0\x81\x12\x15a2OW__\xFD[`@\x81\x12\x15a2\\W__\xFD[\x85\x94P``\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x82\x01\x12\x15a2\x8EW__\xFD[P`@\x85\x01\x92P`\xA0\x85\x015`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a2\xAEW__\xFD[\x93\x96\x92\x95P\x92\x93`\xC0\x015\x92PPV[\x87\x81R`\xE0` \x82\x01R_a2\xD6`\xE0\x83\x01\x89a12V[`\x01`\x01`\xA0\x1B\x03\x97\x88\x16`@\x84\x01R``\x83\x01\x96\x90\x96RP\x92\x85\x16`\x80\x84\x01R\x93\x16`\xA0\x82\x01R`\xC0\x01\x91\x90\x91R\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[__\x19\x82\x03a3IWa3Ia3\x0BV[P`\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`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`\xA0\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a3\xCDWa3\xCDa3PV[`@R\x90V[_\x82`\x1F\x83\x01\x12a3\xE2W__\xFD[\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a3\xFCWa3\xFCa3PV[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a4+Wa4+a3PV[`@R\x81\x81R\x83\x82\x01` \x01\x85\x10\x15a4BW__\xFD[\x81` \x85\x01` \x83\x017_\x91\x81\x01` \x01\x91\x90\x91R\x93\x92PPPV[_` \x826\x03\x12\x15a4nW__\xFD[`@Q` \x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a4\x91Wa4\x91a3PV[`@R\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a4\xAAW__\xFD[a4\xB66\x82\x86\x01a3\xD3V[\x82RP\x92\x91PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a4\xD3W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a5\nW\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[P\x91\x90PV[`\x1F\x82\x11\x15a\x17SW\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a55WP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a5TW_\x81U`\x01\x01a5AV[PPPPPV[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a5uWa5ua3PV[a5\x89\x81a5\x83\x84Ta4\xBFV[\x84a5\x10V[` `\x1F\x82\x11`\x01\x81\x14a5\xBBW_\x83\x15a5\xA4WP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua5TV[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a5\xEAW\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a5\xCAV[P\x84\x82\x10\x15a6\x07W\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV[\x81\x83R\x81\x81` \x85\x017P_` \x82\x84\x01\x01R_` `\x1F\x19`\x1F\x84\x01\x16\x84\x01\x01\x90P\x92\x91PPV[``\x81R_\x845\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x866\x03\x01\x81\x12a6uW__\xFD[\x85\x01` \x81\x01\x905g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a6\x91W__\xFD[\x806\x03\x82\x13\x15a6\x9FW__\xFD[` ``\x85\x01Ra6\xB4`\x80\x85\x01\x82\x84a6\x16V[`\x01`\x01`\xA0\x1B\x03\x96\x90\x96\x16` \x85\x01RPPP`@\x01R\x91\x90PV[__\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\x12a7\x04W__\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a7\x1EW__\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a'+W__\xFD[` \x81R_a\x14z` \x83\x01\x84\x86a6\x16V[\x805\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\x14a7tW__\xFD[\x91\x90PV[_`\x80\x826\x03\x12\x15a7\x89W__\xFD[`@Q`\x80\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a7\xACWa7\xACa3PV[`@Ra7\xB8\x83a7EV[\x81R` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a7\xD3W__\xFD[a7\xDF6\x82\x86\x01a3\xD3V[` \x83\x01RP`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a7\xFEW__\xFD[a8\n6\x82\x86\x01a3\xD3V[`@\x83\x01RPa8\x1C``\x84\x01a7EV[``\x82\x01R\x92\x91PPV[_`\xA0\x826\x03\x12\x15a87W__\xFD[a8?a3\xAAV[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a8UW__\xFD[a8a6\x82\x86\x01a3\xD3V[\x82RP` \x83\x81\x015\x90\x82\x01R`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a8\x87W__\xFD[a8\x936\x82\x86\x01a3\xD3V[`@\x83\x01RP``\x83\x81\x015\x90\x82\x01R`\x80\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a8\xBCW__\xFD[a8\xC86\x82\x86\x01a3\xD3V[`\x80\x83\x01RP\x92\x91PPV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a7tW__\xFD[_`@\x82\x84\x03\x12\x80\x15a8\xF8W__\xFD[P`@\x80Q\x90\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a9\x1CWa9\x1Ca3PV[`@R\x825\x81Ra9/` \x84\x01a8\xD4V[` \x82\x01R\x93\x92PPPV[_``\x82\x84\x03\x12\x80\x15a9LW__\xFD[P`@Q``\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a9pWa9pa3PV[`@R\x825\x81Ra9\x83` \x84\x01a8\xD4V[` \x82\x01R`@\x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a9\xA2W__\xFD[`@\x82\x01R\x93\x92PPPV[\x835\x81R`\x80\x81\x01c\xFF\xFF\xFF\xFFa9\xC7` \x87\x01a8\xD4V[\x16` \x83\x01R`\x01`\x01`\xA0\x1B\x03\x93\x90\x93\x16`@\x82\x01R``\x01R\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x07$Wa\x07$a3\x0BV[\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\x83`\xF8\x1B\x16\x81R__\x83Ta:/\x81a4\xBFV[`\x01\x82\x16\x80\x15a:FW`\x01\x81\x14a:\x7FWa:\xB5V[\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\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\x83\x16`\x01\x87\x01R`\x01\x82\x15\x15\x83\x02\x87\x01\x01\x93Pa:\xB5V[\x86_R` _ _[\x83\x81\x10\x15a:\xAAW\x81T`\x01\x82\x8A\x01\x01R`\x01\x82\x01\x91P` \x81\x01\x90Pa:\x88V[PP`\x01\x82\x87\x01\x01\x93P[P\x91\x96\x95PPPPPPV[_` \x82\x84\x03\x12\x15a:\xD1W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x1F\xB0W__\xFD[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[\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\x85\x16\x81R_a;3a;-`\x04\x84\x01\x87a:\xE0V[\x85a:\xE0V[\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\x93\x90\x93\x16\x83RPP`\x04\x01\x93\x92PPPV[_a\x1F\xB0\x82\x84a:\xE0V[_` \x82\x84\x03\x12\x15a;\x81W__\xFD[PQ\x91\x90PV[\x80\x82\x02\x81\x15\x82\x82\x04\x84\x14\x17a\x07$Wa\x07$a3\x0BV[\x81\x81\x03\x81\x81\x11\x15a\x07$Wa\x07$a3\x0BV[g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x07$Wa\x07$a3\x0BV[\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<\rWa<\ra;\xD2V[P\x06\x90V[`\xFF\x81\x81\x16\x83\x82\x16\x01\x90\x81\x11\x15a\x07$Wa\x07$a3\x0BV[`\xFF\x82\x81\x16\x82\x82\x16\x03\x90\x81\x11\x15a\x07$Wa\x07$a3\x0BV[`\x01\x81[`\x01\x84\x11\x15a<\x7FW\x80\x85\x04\x81\x11\x15a::RustType, - #[allow(missing_docs)] - pub ercToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub ercAmount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub requester: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub acceptor: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub acceptTime: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - BitcoinAddress, - 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, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ::RustType, - alloy::sol_types::private::Address, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: AcceptedOrdinalSellOrder) -> Self { - ( - value.orderId, - value.bitcoinAddress, - value.ercToken, - value.ercAmount, - value.requester, - value.acceptor, - value.acceptTime, - ) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for AcceptedOrdinalSellOrder { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - orderId: tuple.0, - bitcoinAddress: tuple.1, - ercToken: tuple.2, - ercAmount: tuple.3, - requester: tuple.4, - acceptor: tuple.5, - acceptTime: tuple.6, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for AcceptedOrdinalSellOrder { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for AcceptedOrdinalSellOrder { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.orderId), - ::tokenize( - &self.bitcoinAddress, - ), - ::tokenize( - &self.ercToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.ercAmount), - ::tokenize( - &self.requester, - ), - ::tokenize( - &self.acceptor, - ), - as alloy_sol_types::SolType>::tokenize(&self.acceptTime), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for AcceptedOrdinalSellOrder { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for AcceptedOrdinalSellOrder { - const NAME: &'static str = "AcceptedOrdinalSellOrder"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "AcceptedOrdinalSellOrder(uint256 orderId,BitcoinAddress bitcoinAddress,address ercToken,uint256 ercAmount,address requester,address acceptor,uint256 acceptTime)", - ) - } - #[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( - ::eip712_root_type(), - ); - components - .extend( - ::eip712_components(), - ); - components - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - as alloy_sol_types::SolType>::eip712_data_word(&self.orderId) - .0, - ::eip712_data_word( - &self.bitcoinAddress, - ) - .0, - ::eip712_data_word( - &self.ercToken, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.ercAmount) - .0, - ::eip712_data_word( - &self.requester, - ) - .0, - ::eip712_data_word( - &self.acceptor, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.acceptTime) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for AcceptedOrdinalSellOrder { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.orderId, - ) - + ::topic_preimage_length( - &rust.bitcoinAddress, - ) - + ::topic_preimage_length( - &rust.ercToken, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.ercAmount, - ) - + ::topic_preimage_length( - &rust.requester, - ) - + ::topic_preimage_length( - &rust.acceptor, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.acceptTime, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.orderId, - out, - ); - ::encode_topic_preimage( - &rust.bitcoinAddress, - out, - ); - ::encode_topic_preimage( - &rust.ercToken, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.ercAmount, - out, - ); - ::encode_topic_preimage( - &rust.requester, - out, - ); - ::encode_topic_preimage( - &rust.acceptor, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.acceptTime, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct BitcoinAddress { bytes scriptPubKey; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct BitcoinAddress { - #[allow(missing_docs)] - pub scriptPubKey: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: BitcoinAddress) -> Self { - (value.scriptPubKey,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for BitcoinAddress { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { scriptPubKey: tuple.0 } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for BitcoinAddress { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for BitcoinAddress { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.scriptPubKey, - ), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for BitcoinAddress { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for BitcoinAddress { - const NAME: &'static str = "BitcoinAddress"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "BitcoinAddress(bytes scriptPubKey)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - ::eip712_data_word( - &self.scriptPubKey, - ) - .0 - .to_vec() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for BitcoinAddress { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.scriptPubKey, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.scriptPubKey, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct OrdinalId { bytes32 txId; uint32 index; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct OrdinalId { - #[allow(missing_docs)] - pub txId: alloy::sol_types::private::FixedBytes<32>, - #[allow(missing_docs)] - pub index: u32, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Uint<32>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>, u32); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: OrdinalId) -> Self { - (value.txId, value.index) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for OrdinalId { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - txId: tuple.0, - index: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for OrdinalId { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for OrdinalId { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.txId), - as alloy_sol_types::SolType>::tokenize(&self.index), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for OrdinalId { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for OrdinalId { - const NAME: &'static str = "OrdinalId"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "OrdinalId(bytes32 txId,uint32 index)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - as alloy_sol_types::SolType>::eip712_data_word(&self.txId) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.index) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for OrdinalId { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.txId) - + as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.index) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.txId, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.index, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct OrdinalSellOrder { OrdinalId ordinalID; address sellToken; uint256 sellAmount; BitcoinTx.UTXO utxo; address requester; bool isOrderAccepted; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct OrdinalSellOrder { - #[allow(missing_docs)] - pub ordinalID: ::RustType, - #[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 utxo: ::RustType, - #[allow(missing_docs)] - pub requester: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub isOrderAccepted: bool, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - OrdinalId, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - BitcoinTx::UTXO, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Bool, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - ::RustType, - alloy::sol_types::private::Address, - alloy::sol_types::private::primitives::aliases::U256, - ::RustType, - alloy::sol_types::private::Address, - bool, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: OrdinalSellOrder) -> Self { - ( - value.ordinalID, - value.sellToken, - value.sellAmount, - value.utxo, - value.requester, - value.isOrderAccepted, - ) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for OrdinalSellOrder { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - ordinalID: tuple.0, - sellToken: tuple.1, - sellAmount: tuple.2, - utxo: tuple.3, - requester: tuple.4, - isOrderAccepted: tuple.5, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for OrdinalSellOrder { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for OrdinalSellOrder { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize(&self.ordinalID), - ::tokenize( - &self.sellToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.sellAmount), - ::tokenize(&self.utxo), - ::tokenize( - &self.requester, - ), - ::tokenize( - &self.isOrderAccepted, - ), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for OrdinalSellOrder { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for OrdinalSellOrder { - const NAME: &'static str = "OrdinalSellOrder"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "OrdinalSellOrder(OrdinalId ordinalID,address sellToken,uint256 sellAmount,BitcoinTx.UTXO utxo,address requester,bool isOrderAccepted)", - ) - } - #[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(::eip712_root_type()); - components - .extend( - ::eip712_components(), - ); - components - .push( - ::eip712_root_type(), - ); - components - .extend( - ::eip712_components(), - ); - components - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.ordinalID, - ) - .0, - ::eip712_data_word( - &self.sellToken, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.sellAmount) - .0, - ::eip712_data_word( - &self.utxo, - ) - .0, - ::eip712_data_word( - &self.requester, - ) - .0, - ::eip712_data_word( - &self.isOrderAccepted, - ) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for OrdinalSellOrder { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.ordinalID, - ) - + ::topic_preimage_length( - &rust.sellToken, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.sellAmount, - ) - + ::topic_preimage_length( - &rust.utxo, - ) - + ::topic_preimage_length( - &rust.requester, - ) - + ::topic_preimage_length( - &rust.isOrderAccepted, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.ordinalID, - out, - ); - ::encode_topic_preimage( - &rust.sellToken, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.sellAmount, - out, - ); - ::encode_topic_preimage( - &rust.utxo, - out, - ); - ::encode_topic_preimage( - &rust.requester, - out, - ); - ::encode_topic_preimage( - &rust.isOrderAccepted, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `acceptOrdinalSellOrderEvent(uint256,uint256,(bytes),address,uint256)` and selector `0xfe350ff9ccadd1b7c26b5f96dd078d08a877c8f37d506931ecd8f2bdbd51b6f2`. -```solidity -event acceptOrdinalSellOrderEvent(uint256 indexed id, uint256 indexed acceptId, BitcoinAddress bitcoinAddress, address ercToken, uint256 ercAmount); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct acceptOrdinalSellOrderEvent { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub acceptId: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub bitcoinAddress: ::RustType, - #[allow(missing_docs)] - pub ercToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub ercAmount: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for acceptOrdinalSellOrderEvent { - type DataTuple<'a> = ( - BitcoinAddress, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - const SIGNATURE: &'static str = "acceptOrdinalSellOrderEvent(uint256,uint256,(bytes),address,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 254u8, 53u8, 15u8, 249u8, 204u8, 173u8, 209u8, 183u8, 194u8, 107u8, 95u8, - 150u8, 221u8, 7u8, 141u8, 8u8, 168u8, 119u8, 200u8, 243u8, 125u8, 80u8, - 105u8, 49u8, 236u8, 216u8, 242u8, 189u8, 189u8, 81u8, 182u8, 242u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - id: topics.1, - acceptId: topics.2, - bitcoinAddress: data.0, - ercToken: data.1, - ercAmount: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.bitcoinAddress, - ), - ::tokenize( - &self.ercToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.ercAmount), - ) - } - #[inline] - fn topics(&self) -> ::RustType { - (Self::SIGNATURE_HASH.into(), self.id.clone(), self.acceptId.clone()) - } - #[inline] - fn encode_topics_raw( - &self, - out: &mut [alloy_sol_types::abi::token::WordToken], - ) -> alloy_sol_types::Result<()> { - if out.len() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.id); - out[2usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.acceptId); - Ok(()) - } - } - #[automatically_derived] - impl alloy_sol_types::private::IntoLogData for acceptOrdinalSellOrderEvent { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&acceptOrdinalSellOrderEvent> for alloy_sol_types::private::LogData { - #[inline] - fn from( - this: &acceptOrdinalSellOrderEvent, - ) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `cancelAcceptedOrdinalSellOrderEvent(uint256)` and selector `0x9c216a4617d6c03dc7cbd9632166f1c5c9ef41f9ee86bf3b83f671c005107704`. -```solidity -event cancelAcceptedOrdinalSellOrderEvent(uint256 id); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct cancelAcceptedOrdinalSellOrderEvent { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for cancelAcceptedOrdinalSellOrderEvent { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "cancelAcceptedOrdinalSellOrderEvent(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 33u8, 106u8, 70u8, 23u8, 214u8, 192u8, 61u8, 199u8, 203u8, 217u8, - 99u8, 33u8, 102u8, 241u8, 197u8, 201u8, 239u8, 65u8, 249u8, 238u8, 134u8, - 191u8, 59u8, 131u8, 246u8, 113u8, 192u8, 5u8, 16u8, 119u8, 4u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { id: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 cancelAcceptedOrdinalSellOrderEvent { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&cancelAcceptedOrdinalSellOrderEvent> - for alloy_sol_types::private::LogData { - #[inline] - fn from( - this: &cancelAcceptedOrdinalSellOrderEvent, - ) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `placeOrdinalSellOrderEvent(uint256,(bytes32,uint32),address,uint256)` and selector `0xfb2d3310e3e79578ac507cdbdb32e52581dbc17be04e5197d3b7c522735fb9e4`. -```solidity -event placeOrdinalSellOrderEvent(uint256 indexed orderId, OrdinalId ordinalID, address sellToken, uint256 sellAmount); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct placeOrdinalSellOrderEvent { - #[allow(missing_docs)] - pub orderId: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub ordinalID: ::RustType, - #[allow(missing_docs)] - pub sellToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub sellAmount: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for placeOrdinalSellOrderEvent { - type DataTuple<'a> = ( - OrdinalId, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Uint<256>, - ); - const SIGNATURE: &'static str = "placeOrdinalSellOrderEvent(uint256,(bytes32,uint32),address,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 45u8, 51u8, 16u8, 227u8, 231u8, 149u8, 120u8, 172u8, 80u8, 124u8, - 219u8, 219u8, 50u8, 229u8, 37u8, 129u8, 219u8, 193u8, 123u8, 224u8, 78u8, - 81u8, 151u8, 211u8, 183u8, 197u8, 34u8, 115u8, 95u8, 185u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - orderId: topics.1, - ordinalID: data.0, - sellToken: data.1, - sellAmount: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize(&self.ordinalID), - ::tokenize( - &self.sellToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.sellAmount), - ) - } - #[inline] - fn topics(&self) -> ::RustType { - (Self::SIGNATURE_HASH.into(), self.orderId.clone()) - } - #[inline] - fn encode_topics_raw( - &self, - out: &mut [alloy_sol_types::abi::token::WordToken], - ) -> alloy_sol_types::Result<()> { - if out.len() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.orderId); - Ok(()) - } - } - #[automatically_derived] - impl alloy_sol_types::private::IntoLogData for placeOrdinalSellOrderEvent { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&placeOrdinalSellOrderEvent> for alloy_sol_types::private::LogData { - #[inline] - fn from( - this: &placeOrdinalSellOrderEvent, - ) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `proofOrdinalSellOrderEvent(uint256)` and selector `0xc577309acd7939cc2f01f67f073e1a548224454cdddc79b161db17b5315e9f0c`. -```solidity -event proofOrdinalSellOrderEvent(uint256 id); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct proofOrdinalSellOrderEvent { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for proofOrdinalSellOrderEvent { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "proofOrdinalSellOrderEvent(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 197u8, 119u8, 48u8, 154u8, 205u8, 121u8, 57u8, 204u8, 47u8, 1u8, 246u8, - 127u8, 7u8, 62u8, 26u8, 84u8, 130u8, 36u8, 69u8, 76u8, 221u8, 220u8, - 121u8, 177u8, 97u8, 219u8, 23u8, 181u8, 49u8, 94u8, 159u8, 12u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { id: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 proofOrdinalSellOrderEvent { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&proofOrdinalSellOrderEvent> for alloy_sol_types::private::LogData { - #[inline] - fn from( - this: &proofOrdinalSellOrderEvent, - ) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `withdrawOrdinalSellOrderEvent(uint256)` and selector `0xb35b3fe4daaf6cc66eb8bd413e9ab54449e766f6d46125cc58f255694a0e847e`. -```solidity -event withdrawOrdinalSellOrderEvent(uint256 id); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct withdrawOrdinalSellOrderEvent { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for withdrawOrdinalSellOrderEvent { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "withdrawOrdinalSellOrderEvent(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 179u8, 91u8, 63u8, 228u8, 218u8, 175u8, 108u8, 198u8, 110u8, 184u8, - 189u8, 65u8, 62u8, 154u8, 181u8, 68u8, 73u8, 231u8, 102u8, 246u8, 212u8, - 97u8, 37u8, 204u8, 88u8, 242u8, 85u8, 105u8, 74u8, 14u8, 132u8, 126u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { id: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 withdrawOrdinalSellOrderEvent { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&withdrawOrdinalSellOrderEvent> for alloy_sol_types::private::LogData { - #[inline] - fn from( - this: &withdrawOrdinalSellOrderEvent, - ) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - /**Constructor`. -```solidity -constructor(address _relay); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct constructorCall { - #[allow(missing_docs)] - pub _relay: alloy::sol_types::private::Address, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value._relay,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _relay: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolConstructor for constructorCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._relay, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `REQUEST_EXPIRATION_SECONDS()` and selector `0xd1920ff0`. -```solidity -function REQUEST_EXPIRATION_SECONDS() external view returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct REQUEST_EXPIRATION_SECONDSCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`REQUEST_EXPIRATION_SECONDS()`](REQUEST_EXPIRATION_SECONDSCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct REQUEST_EXPIRATION_SECONDSReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: REQUEST_EXPIRATION_SECONDSCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for REQUEST_EXPIRATION_SECONDSCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: REQUEST_EXPIRATION_SECONDSReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for REQUEST_EXPIRATION_SECONDSReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for REQUEST_EXPIRATION_SECONDSCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "REQUEST_EXPIRATION_SECONDS()"; - const SELECTOR: [u8; 4] = [209u8, 146u8, 15u8, 240u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: REQUEST_EXPIRATION_SECONDSReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: REQUEST_EXPIRATION_SECONDSReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `acceptOrdinalSellOrder(uint256,(bytes))` and selector `0x2814a1cd`. -```solidity -function acceptOrdinalSellOrder(uint256 id, BitcoinAddress memory bitcoinAddress) external returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct acceptOrdinalSellOrderCall { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub bitcoinAddress: ::RustType, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`acceptOrdinalSellOrder(uint256,(bytes))`](acceptOrdinalSellOrderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct acceptOrdinalSellOrderReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - BitcoinAddress, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ::RustType, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: acceptOrdinalSellOrderCall) -> Self { - (value.id, value.bitcoinAddress) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for acceptOrdinalSellOrderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - id: tuple.0, - bitcoinAddress: tuple.1, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: acceptOrdinalSellOrderReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for acceptOrdinalSellOrderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for acceptOrdinalSellOrderCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - BitcoinAddress, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "acceptOrdinalSellOrder(uint256,(bytes))"; - const SELECTOR: [u8; 4] = [40u8, 20u8, 161u8, 205u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - ::tokenize( - &self.bitcoinAddress, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: acceptOrdinalSellOrderReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: acceptOrdinalSellOrderReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `acceptedOrdinalSellOrders(uint256)` and selector `0xdb82d5fa`. -```solidity -function acceptedOrdinalSellOrders(uint256) external view returns (uint256 orderId, BitcoinAddress memory bitcoinAddress, address ercToken, uint256 ercAmount, address requester, address acceptor, uint256 acceptTime); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct acceptedOrdinalSellOrdersCall( - pub alloy::sol_types::private::primitives::aliases::U256, - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`acceptedOrdinalSellOrders(uint256)`](acceptedOrdinalSellOrdersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct acceptedOrdinalSellOrdersReturn { - #[allow(missing_docs)] - pub orderId: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub bitcoinAddress: ::RustType, - #[allow(missing_docs)] - pub ercToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub ercAmount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub requester: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub acceptor: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub acceptTime: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: acceptedOrdinalSellOrdersCall) -> Self { - (value.0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for acceptedOrdinalSellOrdersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self(tuple.0) - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - BitcoinAddress, - 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, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ::RustType, - alloy::sol_types::private::Address, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: acceptedOrdinalSellOrdersReturn) -> Self { - ( - value.orderId, - value.bitcoinAddress, - value.ercToken, - value.ercAmount, - value.requester, - value.acceptor, - value.acceptTime, - ) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for acceptedOrdinalSellOrdersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - orderId: tuple.0, - bitcoinAddress: tuple.1, - ercToken: tuple.2, - ercAmount: tuple.3, - requester: tuple.4, - acceptor: tuple.5, - acceptTime: tuple.6, - } - } - } - } - impl acceptedOrdinalSellOrdersReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - ( - as alloy_sol_types::SolType>::tokenize(&self.orderId), - ::tokenize( - &self.bitcoinAddress, - ), - ::tokenize( - &self.ercToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.ercAmount), - ::tokenize( - &self.requester, - ), - ::tokenize( - &self.acceptor, - ), - as alloy_sol_types::SolType>::tokenize(&self.acceptTime), - ) - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for acceptedOrdinalSellOrdersCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = acceptedOrdinalSellOrdersReturn; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - BitcoinAddress, - 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, - alloy::sol_types::sol_data::Uint<256>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "acceptedOrdinalSellOrders(uint256)"; - const SELECTOR: [u8; 4] = [219u8, 130u8, 213u8, 250u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.0), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - acceptedOrdinalSellOrdersReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `cancelAcceptedOrdinalSellOrder(uint256)` and selector `0x73787155`. -```solidity -function cancelAcceptedOrdinalSellOrder(uint256 id) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct cancelAcceptedOrdinalSellOrderCall { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - } - ///Container type for the return parameters of the [`cancelAcceptedOrdinalSellOrder(uint256)`](cancelAcceptedOrdinalSellOrderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct cancelAcceptedOrdinalSellOrderReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: cancelAcceptedOrdinalSellOrderCall) -> Self { - (value.id,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for cancelAcceptedOrdinalSellOrderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { id: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: cancelAcceptedOrdinalSellOrderReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for cancelAcceptedOrdinalSellOrderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl cancelAcceptedOrdinalSellOrderReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for cancelAcceptedOrdinalSellOrderCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = cancelAcceptedOrdinalSellOrderReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "cancelAcceptedOrdinalSellOrder(uint256)"; - const SELECTOR: [u8; 4] = [115u8, 120u8, 113u8, 85u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - cancelAcceptedOrdinalSellOrderReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getOpenAcceptedOrdinalSellOrders()` and selector `0x3c49febe`. -```solidity -function getOpenAcceptedOrdinalSellOrders() external view returns (AcceptedOrdinalSellOrder[] memory, uint256[] memory); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getOpenAcceptedOrdinalSellOrdersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getOpenAcceptedOrdinalSellOrders()`](getOpenAcceptedOrdinalSellOrdersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getOpenAcceptedOrdinalSellOrdersReturn { - #[allow(missing_docs)] - pub _0: alloy::sol_types::private::Vec< - ::RustType, - >, - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getOpenAcceptedOrdinalSellOrdersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getOpenAcceptedOrdinalSellOrdersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getOpenAcceptedOrdinalSellOrdersReturn) -> Self { - (value._0, value._1) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getOpenAcceptedOrdinalSellOrdersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0, _1: tuple.1 } - } - } - } - impl getOpenAcceptedOrdinalSellOrdersReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - , - > as alloy_sol_types::SolType>::tokenize(&self._1), - ) - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getOpenAcceptedOrdinalSellOrdersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = getOpenAcceptedOrdinalSellOrdersReturn; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - alloy::sol_types::sol_data::Array>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getOpenAcceptedOrdinalSellOrders()"; - const SELECTOR: [u8; 4] = [60u8, 73u8, 254u8, 190u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - getOpenAcceptedOrdinalSellOrdersReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getOpenOrdinalSellOrders()` and selector `0x171abce5`. -```solidity -function getOpenOrdinalSellOrders() external view returns (OrdinalSellOrder[] memory, uint256[] memory); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getOpenOrdinalSellOrdersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getOpenOrdinalSellOrders()`](getOpenOrdinalSellOrdersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getOpenOrdinalSellOrdersReturn { - #[allow(missing_docs)] - pub _0: alloy::sol_types::private::Vec< - ::RustType, - >, - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getOpenOrdinalSellOrdersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getOpenOrdinalSellOrdersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getOpenOrdinalSellOrdersReturn) -> Self { - (value._0, value._1) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getOpenOrdinalSellOrdersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0, _1: tuple.1 } - } - } - } - impl getOpenOrdinalSellOrdersReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - , - > as alloy_sol_types::SolType>::tokenize(&self._1), - ) - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getOpenOrdinalSellOrdersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = getOpenOrdinalSellOrdersReturn; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - alloy::sol_types::sol_data::Array>, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getOpenOrdinalSellOrders()"; - const SELECTOR: [u8; 4] = [23u8, 26u8, 188u8, 229u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - getOpenOrdinalSellOrdersReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `ordinalSellOrders(uint256)` and selector `0x2b260fa0`. -```solidity -function ordinalSellOrders(uint256) external view returns (OrdinalId memory ordinalID, address sellToken, uint256 sellAmount, BitcoinTx.UTXO memory utxo, address requester, bool isOrderAccepted); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct ordinalSellOrdersCall( - pub alloy::sol_types::private::primitives::aliases::U256, - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`ordinalSellOrders(uint256)`](ordinalSellOrdersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct ordinalSellOrdersReturn { - #[allow(missing_docs)] - pub ordinalID: ::RustType, - #[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 utxo: ::RustType, - #[allow(missing_docs)] - pub requester: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub isOrderAccepted: bool, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: ordinalSellOrdersCall) -> Self { - (value.0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for ordinalSellOrdersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self(tuple.0) - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - OrdinalId, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - BitcoinTx::UTXO, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Bool, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - ::RustType, - alloy::sol_types::private::Address, - alloy::sol_types::private::primitives::aliases::U256, - ::RustType, - alloy::sol_types::private::Address, - bool, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: ordinalSellOrdersReturn) -> Self { - ( - value.ordinalID, - value.sellToken, - value.sellAmount, - value.utxo, - value.requester, - value.isOrderAccepted, - ) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for ordinalSellOrdersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - ordinalID: tuple.0, - sellToken: tuple.1, - sellAmount: tuple.2, - utxo: tuple.3, - requester: tuple.4, - isOrderAccepted: tuple.5, - } - } - } - } - impl ordinalSellOrdersReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - ( - ::tokenize(&self.ordinalID), - ::tokenize( - &self.sellToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.sellAmount), - ::tokenize(&self.utxo), - ::tokenize( - &self.requester, - ), - ::tokenize( - &self.isOrderAccepted, - ), - ) - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for ordinalSellOrdersCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = ordinalSellOrdersReturn; - type ReturnTuple<'a> = ( - OrdinalId, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - BitcoinTx::UTXO, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Bool, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "ordinalSellOrders(uint256)"; - const SELECTOR: [u8; 4] = [43u8, 38u8, 15u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.0), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ordinalSellOrdersReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `placeOrdinalSellOrder((bytes32,uint32),(bytes32,uint32,uint64),address,uint256)` and selector `0x5c9ddc84`. -```solidity -function placeOrdinalSellOrder(OrdinalId memory ordinalID, BitcoinTx.UTXO memory utxo, address sellToken, uint256 sellAmount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct placeOrdinalSellOrderCall { - #[allow(missing_docs)] - pub ordinalID: ::RustType, - #[allow(missing_docs)] - pub utxo: ::RustType, - #[allow(missing_docs)] - pub sellToken: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub sellAmount: alloy::sol_types::private::primitives::aliases::U256, - } - ///Container type for the return parameters of the [`placeOrdinalSellOrder((bytes32,uint32),(bytes32,uint32,uint64),address,uint256)`](placeOrdinalSellOrderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct placeOrdinalSellOrderReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - OrdinalId, - BitcoinTx::UTXO, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - ::RustType, - ::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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: placeOrdinalSellOrderCall) -> Self { - (value.ordinalID, value.utxo, value.sellToken, value.sellAmount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for placeOrdinalSellOrderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - ordinalID: tuple.0, - utxo: tuple.1, - sellToken: tuple.2, - sellAmount: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: placeOrdinalSellOrderReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for placeOrdinalSellOrderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl placeOrdinalSellOrderReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for placeOrdinalSellOrderCall { - type Parameters<'a> = ( - OrdinalId, - BitcoinTx::UTXO, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = placeOrdinalSellOrderReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "placeOrdinalSellOrder((bytes32,uint32),(bytes32,uint32,uint64),address,uint256)"; - const SELECTOR: [u8; 4] = [92u8, 157u8, 220u8, 132u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize(&self.ordinalID), - ::tokenize(&self.utxo), - ::tokenize( - &self.sellToken, - ), - as alloy_sol_types::SolType>::tokenize(&self.sellAmount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - placeOrdinalSellOrderReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `proofOrdinalSellOrder(uint256,(bytes4,bytes,bytes,bytes4),(bytes,uint256,bytes,bytes32,bytes))` and selector `0x2d7359c6`. -```solidity -function proofOrdinalSellOrder(uint256 id, BitcoinTx.Info memory transaction, BitcoinTx.Proof memory proof) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct proofOrdinalSellOrderCall { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub transaction: ::RustType, - #[allow(missing_docs)] - pub proof: ::RustType, - } - ///Container type for the return parameters of the [`proofOrdinalSellOrder(uint256,(bytes4,bytes,bytes,bytes4),(bytes,uint256,bytes,bytes32,bytes))`](proofOrdinalSellOrderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct proofOrdinalSellOrderReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - BitcoinTx::Info, - BitcoinTx::Proof, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ::RustType, - ::RustType, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: proofOrdinalSellOrderCall) -> Self { - (value.id, value.transaction, value.proof) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for proofOrdinalSellOrderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - id: tuple.0, - transaction: tuple.1, - proof: tuple.2, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: proofOrdinalSellOrderReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for proofOrdinalSellOrderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl proofOrdinalSellOrderReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for proofOrdinalSellOrderCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Uint<256>, - BitcoinTx::Info, - BitcoinTx::Proof, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = proofOrdinalSellOrderReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "proofOrdinalSellOrder(uint256,(bytes4,bytes,bytes,bytes4),(bytes,uint256,bytes,bytes32,bytes))"; - const SELECTOR: [u8; 4] = [45u8, 115u8, 89u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - ::tokenize( - &self.transaction, - ), - ::tokenize(&self.proof), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - proofOrdinalSellOrderReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `withdrawOrdinalSellOrder(uint256)` and selector `0xe4ae61dd`. -```solidity -function withdrawOrdinalSellOrder(uint256 id) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct withdrawOrdinalSellOrderCall { - #[allow(missing_docs)] - pub id: alloy::sol_types::private::primitives::aliases::U256, - } - ///Container type for the return parameters of the [`withdrawOrdinalSellOrder(uint256)`](withdrawOrdinalSellOrderCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct withdrawOrdinalSellOrderReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: withdrawOrdinalSellOrderCall) -> Self { - (value.id,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for withdrawOrdinalSellOrderCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { id: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: withdrawOrdinalSellOrderReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for withdrawOrdinalSellOrderReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl withdrawOrdinalSellOrderReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for withdrawOrdinalSellOrderCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = withdrawOrdinalSellOrderReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "withdrawOrdinalSellOrder(uint256)"; - const SELECTOR: [u8; 4] = [228u8, 174u8, 97u8, 221u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.id), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - withdrawOrdinalSellOrderReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`OrdMarketplace`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum OrdMarketplaceCalls { - #[allow(missing_docs)] - REQUEST_EXPIRATION_SECONDS(REQUEST_EXPIRATION_SECONDSCall), - #[allow(missing_docs)] - acceptOrdinalSellOrder(acceptOrdinalSellOrderCall), - #[allow(missing_docs)] - acceptedOrdinalSellOrders(acceptedOrdinalSellOrdersCall), - #[allow(missing_docs)] - cancelAcceptedOrdinalSellOrder(cancelAcceptedOrdinalSellOrderCall), - #[allow(missing_docs)] - getOpenAcceptedOrdinalSellOrders(getOpenAcceptedOrdinalSellOrdersCall), - #[allow(missing_docs)] - getOpenOrdinalSellOrders(getOpenOrdinalSellOrdersCall), - #[allow(missing_docs)] - ordinalSellOrders(ordinalSellOrdersCall), - #[allow(missing_docs)] - placeOrdinalSellOrder(placeOrdinalSellOrderCall), - #[allow(missing_docs)] - proofOrdinalSellOrder(proofOrdinalSellOrderCall), - #[allow(missing_docs)] - withdrawOrdinalSellOrder(withdrawOrdinalSellOrderCall), - } - #[automatically_derived] - impl OrdMarketplaceCalls { - /// 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]] = &[ - [23u8, 26u8, 188u8, 229u8], - [40u8, 20u8, 161u8, 205u8], - [43u8, 38u8, 15u8, 160u8], - [45u8, 115u8, 89u8, 198u8], - [60u8, 73u8, 254u8, 190u8], - [92u8, 157u8, 220u8, 132u8], - [115u8, 120u8, 113u8, 85u8], - [209u8, 146u8, 15u8, 240u8], - [219u8, 130u8, 213u8, 250u8], - [228u8, 174u8, 97u8, 221u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for OrdMarketplaceCalls { - const NAME: &'static str = "OrdMarketplaceCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 10usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::REQUEST_EXPIRATION_SECONDS(_) => { - ::SELECTOR - } - Self::acceptOrdinalSellOrder(_) => { - ::SELECTOR - } - Self::acceptedOrdinalSellOrders(_) => { - ::SELECTOR - } - Self::cancelAcceptedOrdinalSellOrder(_) => { - ::SELECTOR - } - Self::getOpenAcceptedOrdinalSellOrders(_) => { - ::SELECTOR - } - Self::getOpenOrdinalSellOrders(_) => { - ::SELECTOR - } - Self::ordinalSellOrders(_) => { - ::SELECTOR - } - Self::placeOrdinalSellOrder(_) => { - ::SELECTOR - } - Self::proofOrdinalSellOrder(_) => { - ::SELECTOR - } - Self::withdrawOrdinalSellOrder(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getOpenOrdinalSellOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(OrdMarketplaceCalls::getOpenOrdinalSellOrders) - } - getOpenOrdinalSellOrders - }, - { - fn acceptOrdinalSellOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(OrdMarketplaceCalls::acceptOrdinalSellOrder) - } - acceptOrdinalSellOrder - }, - { - fn ordinalSellOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(OrdMarketplaceCalls::ordinalSellOrders) - } - ordinalSellOrders - }, - { - fn proofOrdinalSellOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(OrdMarketplaceCalls::proofOrdinalSellOrder) - } - proofOrdinalSellOrder - }, - { - fn getOpenAcceptedOrdinalSellOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(OrdMarketplaceCalls::getOpenAcceptedOrdinalSellOrders) - } - getOpenAcceptedOrdinalSellOrders - }, - { - fn placeOrdinalSellOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(OrdMarketplaceCalls::placeOrdinalSellOrder) - } - placeOrdinalSellOrder - }, - { - fn cancelAcceptedOrdinalSellOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(OrdMarketplaceCalls::cancelAcceptedOrdinalSellOrder) - } - cancelAcceptedOrdinalSellOrder - }, - { - fn REQUEST_EXPIRATION_SECONDS( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(OrdMarketplaceCalls::REQUEST_EXPIRATION_SECONDS) - } - REQUEST_EXPIRATION_SECONDS - }, - { - fn acceptedOrdinalSellOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(OrdMarketplaceCalls::acceptedOrdinalSellOrders) - } - acceptedOrdinalSellOrders - }, - { - fn withdrawOrdinalSellOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(OrdMarketplaceCalls::withdrawOrdinalSellOrder) - } - withdrawOrdinalSellOrder - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn getOpenOrdinalSellOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(OrdMarketplaceCalls::getOpenOrdinalSellOrders) - } - getOpenOrdinalSellOrders - }, - { - fn acceptOrdinalSellOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(OrdMarketplaceCalls::acceptOrdinalSellOrder) - } - acceptOrdinalSellOrder - }, - { - fn ordinalSellOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(OrdMarketplaceCalls::ordinalSellOrders) - } - ordinalSellOrders - }, - { - fn proofOrdinalSellOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(OrdMarketplaceCalls::proofOrdinalSellOrder) - } - proofOrdinalSellOrder - }, - { - fn getOpenAcceptedOrdinalSellOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(OrdMarketplaceCalls::getOpenAcceptedOrdinalSellOrders) - } - getOpenAcceptedOrdinalSellOrders - }, - { - fn placeOrdinalSellOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(OrdMarketplaceCalls::placeOrdinalSellOrder) - } - placeOrdinalSellOrder - }, - { - fn cancelAcceptedOrdinalSellOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(OrdMarketplaceCalls::cancelAcceptedOrdinalSellOrder) - } - cancelAcceptedOrdinalSellOrder - }, - { - fn REQUEST_EXPIRATION_SECONDS( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(OrdMarketplaceCalls::REQUEST_EXPIRATION_SECONDS) - } - REQUEST_EXPIRATION_SECONDS - }, - { - fn acceptedOrdinalSellOrders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(OrdMarketplaceCalls::acceptedOrdinalSellOrders) - } - acceptedOrdinalSellOrders - }, - { - fn withdrawOrdinalSellOrder( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(OrdMarketplaceCalls::withdrawOrdinalSellOrder) - } - withdrawOrdinalSellOrder - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::REQUEST_EXPIRATION_SECONDS(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::acceptOrdinalSellOrder(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::acceptedOrdinalSellOrders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::cancelAcceptedOrdinalSellOrder(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getOpenAcceptedOrdinalSellOrders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::getOpenOrdinalSellOrders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::ordinalSellOrders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::placeOrdinalSellOrder(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::proofOrdinalSellOrder(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::withdrawOrdinalSellOrder(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::REQUEST_EXPIRATION_SECONDS(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::acceptOrdinalSellOrder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::acceptedOrdinalSellOrders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::cancelAcceptedOrdinalSellOrder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getOpenAcceptedOrdinalSellOrders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::getOpenOrdinalSellOrders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::ordinalSellOrders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::placeOrdinalSellOrder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::proofOrdinalSellOrder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::withdrawOrdinalSellOrder(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`OrdMarketplace`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum OrdMarketplaceEvents { - #[allow(missing_docs)] - acceptOrdinalSellOrderEvent(acceptOrdinalSellOrderEvent), - #[allow(missing_docs)] - cancelAcceptedOrdinalSellOrderEvent(cancelAcceptedOrdinalSellOrderEvent), - #[allow(missing_docs)] - placeOrdinalSellOrderEvent(placeOrdinalSellOrderEvent), - #[allow(missing_docs)] - proofOrdinalSellOrderEvent(proofOrdinalSellOrderEvent), - #[allow(missing_docs)] - withdrawOrdinalSellOrderEvent(withdrawOrdinalSellOrderEvent), - } - #[automatically_derived] - impl OrdMarketplaceEvents { - /// 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]] = &[ - [ - 156u8, 33u8, 106u8, 70u8, 23u8, 214u8, 192u8, 61u8, 199u8, 203u8, 217u8, - 99u8, 33u8, 102u8, 241u8, 197u8, 201u8, 239u8, 65u8, 249u8, 238u8, 134u8, - 191u8, 59u8, 131u8, 246u8, 113u8, 192u8, 5u8, 16u8, 119u8, 4u8, - ], - [ - 179u8, 91u8, 63u8, 228u8, 218u8, 175u8, 108u8, 198u8, 110u8, 184u8, - 189u8, 65u8, 62u8, 154u8, 181u8, 68u8, 73u8, 231u8, 102u8, 246u8, 212u8, - 97u8, 37u8, 204u8, 88u8, 242u8, 85u8, 105u8, 74u8, 14u8, 132u8, 126u8, - ], - [ - 197u8, 119u8, 48u8, 154u8, 205u8, 121u8, 57u8, 204u8, 47u8, 1u8, 246u8, - 127u8, 7u8, 62u8, 26u8, 84u8, 130u8, 36u8, 69u8, 76u8, 221u8, 220u8, - 121u8, 177u8, 97u8, 219u8, 23u8, 181u8, 49u8, 94u8, 159u8, 12u8, - ], - [ - 251u8, 45u8, 51u8, 16u8, 227u8, 231u8, 149u8, 120u8, 172u8, 80u8, 124u8, - 219u8, 219u8, 50u8, 229u8, 37u8, 129u8, 219u8, 193u8, 123u8, 224u8, 78u8, - 81u8, 151u8, 211u8, 183u8, 197u8, 34u8, 115u8, 95u8, 185u8, 228u8, - ], - [ - 254u8, 53u8, 15u8, 249u8, 204u8, 173u8, 209u8, 183u8, 194u8, 107u8, 95u8, - 150u8, 221u8, 7u8, 141u8, 8u8, 168u8, 119u8, 200u8, 243u8, 125u8, 80u8, - 105u8, 49u8, 236u8, 216u8, 242u8, 189u8, 189u8, 81u8, 182u8, 242u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for OrdMarketplaceEvents { - const NAME: &'static str = "OrdMarketplaceEvents"; - const COUNT: usize = 5usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::acceptOrdinalSellOrderEvent) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::cancelAcceptedOrdinalSellOrderEvent) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::placeOrdinalSellOrderEvent) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::proofOrdinalSellOrderEvent) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::withdrawOrdinalSellOrderEvent) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 OrdMarketplaceEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::acceptOrdinalSellOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::cancelAcceptedOrdinalSellOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::placeOrdinalSellOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::proofOrdinalSellOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::withdrawOrdinalSellOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::acceptOrdinalSellOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::cancelAcceptedOrdinalSellOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::placeOrdinalSellOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::proofOrdinalSellOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::withdrawOrdinalSellOrderEvent(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`OrdMarketplace`](self) contract instance. - -See the [wrapper's documentation](`OrdMarketplaceInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> OrdMarketplaceInstance { - OrdMarketplaceInstance::::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: alloy_contract::private::Network, - >( - provider: P, - _relay: alloy::sol_types::private::Address, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - OrdMarketplaceInstance::::deploy(provider, _relay) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - _relay: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - OrdMarketplaceInstance::::deploy_builder(provider, _relay) - } - /**A [`OrdMarketplace`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`OrdMarketplace`](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 OrdMarketplaceInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for OrdMarketplaceInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("OrdMarketplaceInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > OrdMarketplaceInstance { - /**Creates a new wrapper around an on-chain [`OrdMarketplace`](self) contract instance. - -See the [wrapper's documentation](`OrdMarketplaceInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - _relay: alloy::sol_types::private::Address, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder(provider, _relay); - 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, - _relay: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { _relay }, - )[..], - ] - .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 OrdMarketplaceInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> OrdMarketplaceInstance { - OrdMarketplaceInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > OrdMarketplaceInstance { - /// 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( - &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 [`REQUEST_EXPIRATION_SECONDS`] function. - pub fn REQUEST_EXPIRATION_SECONDS( - &self, - ) -> alloy_contract::SolCallBuilder<&P, REQUEST_EXPIRATION_SECONDSCall, N> { - self.call_builder(&REQUEST_EXPIRATION_SECONDSCall) - } - ///Creates a new call builder for the [`acceptOrdinalSellOrder`] function. - pub fn acceptOrdinalSellOrder( - &self, - id: alloy::sol_types::private::primitives::aliases::U256, - bitcoinAddress: ::RustType, - ) -> alloy_contract::SolCallBuilder<&P, acceptOrdinalSellOrderCall, N> { - self.call_builder( - &acceptOrdinalSellOrderCall { - id, - bitcoinAddress, - }, - ) - } - ///Creates a new call builder for the [`acceptedOrdinalSellOrders`] function. - pub fn acceptedOrdinalSellOrders( - &self, - _0: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, acceptedOrdinalSellOrdersCall, N> { - self.call_builder(&acceptedOrdinalSellOrdersCall(_0)) - } - ///Creates a new call builder for the [`cancelAcceptedOrdinalSellOrder`] function. - pub fn cancelAcceptedOrdinalSellOrder( - &self, - id: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, cancelAcceptedOrdinalSellOrderCall, N> { - self.call_builder( - &cancelAcceptedOrdinalSellOrderCall { - id, - }, - ) - } - ///Creates a new call builder for the [`getOpenAcceptedOrdinalSellOrders`] function. - pub fn getOpenAcceptedOrdinalSellOrders( - &self, - ) -> alloy_contract::SolCallBuilder< - &P, - getOpenAcceptedOrdinalSellOrdersCall, - N, - > { - self.call_builder(&getOpenAcceptedOrdinalSellOrdersCall) - } - ///Creates a new call builder for the [`getOpenOrdinalSellOrders`] function. - pub fn getOpenOrdinalSellOrders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, getOpenOrdinalSellOrdersCall, N> { - self.call_builder(&getOpenOrdinalSellOrdersCall) - } - ///Creates a new call builder for the [`ordinalSellOrders`] function. - pub fn ordinalSellOrders( - &self, - _0: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, ordinalSellOrdersCall, N> { - self.call_builder(&ordinalSellOrdersCall(_0)) - } - ///Creates a new call builder for the [`placeOrdinalSellOrder`] function. - pub fn placeOrdinalSellOrder( - &self, - ordinalID: ::RustType, - utxo: ::RustType, - sellToken: alloy::sol_types::private::Address, - sellAmount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, placeOrdinalSellOrderCall, N> { - self.call_builder( - &placeOrdinalSellOrderCall { - ordinalID, - utxo, - sellToken, - sellAmount, - }, - ) - } - ///Creates a new call builder for the [`proofOrdinalSellOrder`] function. - pub fn proofOrdinalSellOrder( - &self, - id: alloy::sol_types::private::primitives::aliases::U256, - transaction: ::RustType, - proof: ::RustType, - ) -> alloy_contract::SolCallBuilder<&P, proofOrdinalSellOrderCall, N> { - self.call_builder( - &proofOrdinalSellOrderCall { - id, - transaction, - proof, - }, - ) - } - ///Creates a new call builder for the [`withdrawOrdinalSellOrder`] function. - pub fn withdrawOrdinalSellOrder( - &self, - id: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, withdrawOrdinalSellOrderCall, N> { - self.call_builder(&withdrawOrdinalSellOrderCall { id }) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > OrdMarketplaceInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`acceptOrdinalSellOrderEvent`] event. - pub fn acceptOrdinalSellOrderEvent_filter( - &self, - ) -> alloy_contract::Event<&P, acceptOrdinalSellOrderEvent, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`cancelAcceptedOrdinalSellOrderEvent`] event. - pub fn cancelAcceptedOrdinalSellOrderEvent_filter( - &self, - ) -> alloy_contract::Event<&P, cancelAcceptedOrdinalSellOrderEvent, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`placeOrdinalSellOrderEvent`] event. - pub fn placeOrdinalSellOrderEvent_filter( - &self, - ) -> alloy_contract::Event<&P, placeOrdinalSellOrderEvent, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`proofOrdinalSellOrderEvent`] event. - pub fn proofOrdinalSellOrderEvent_filter( - &self, - ) -> alloy_contract::Event<&P, proofOrdinalSellOrderEvent, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`withdrawOrdinalSellOrderEvent`] event. - pub fn withdrawOrdinalSellOrderEvent_filter( - &self, - ) -> alloy_contract::Event<&P, withdrawOrdinalSellOrderEvent, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/ownable.rs b/crates/bindings/src/ownable.rs deleted file mode 100644 index 7e310370a..000000000 --- a/crates/bindings/src/ownable.rs +++ /dev/null @@ -1,1104 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface Ownable { - event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); - - function owner() external view returns (address); - function renounceOwnership() external; - function transferOwnership(address newOwner) external; -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "owner", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "address" - } - ], - "stateMutability": "view" - }, - { - "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": "OwnershipTransferred", - "inputs": [ - { - "name": "previousOwner", - "type": "address", - "indexed": true, - "internalType": "address" - }, - { - "name": "newOwner", - "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 Ownable { - use super::*; - use alloy::sol_types as 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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for OwnershipTransferred { - type DataTuple<'a> = (); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = ( - alloy_sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - 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, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - previousOwner: topics.1, - newOwner: topics.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return 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) -> ::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() < ::COUNT { - return Err(alloy_sol_types::Error::Overrun); - } - out[0usize] = alloy_sol_types::abi::token::WordToken( - Self::SIGNATURE_HASH, - ); - out[1usize] = ::encode_topic( - &self.previousOwner, - ); - out[2usize] = ::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(serde::Serialize, serde::Deserialize)] - #[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(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: ownerCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for ownerCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: ownerReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for ownerReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for ownerCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "owner()"; - const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - 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 { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: ownerReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: renounceOwnershipCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for renounceOwnershipCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: renounceOwnershipReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for renounceOwnershipReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl renounceOwnershipReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for renounceOwnershipCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = renounceOwnershipReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "renounceOwnership()"; - const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8]; - #[inline] - fn new<'a>( - tuple: 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 { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: transferOwnershipCall) -> Self { - (value.newOwner,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for transferOwnershipCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { newOwner: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: transferOwnershipReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for transferOwnershipReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl transferOwnershipReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for transferOwnershipCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = transferOwnershipReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "transferOwnership(address)"; - const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::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 { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`Ownable`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum OwnableCalls { - #[allow(missing_docs)] - owner(ownerCall), - #[allow(missing_docs)] - renounceOwnership(renounceOwnershipCall), - #[allow(missing_docs)] - transferOwnership(transferOwnershipCall), - } - #[automatically_derived] - impl OwnableCalls { - /// 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]] = &[ - [113u8, 80u8, 24u8, 166u8], - [141u8, 165u8, 203u8, 91u8], - [242u8, 253u8, 227u8, 139u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for OwnableCalls { - const NAME: &'static str = "OwnableCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 3usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::owner(_) => ::SELECTOR, - Self::renounceOwnership(_) => { - ::SELECTOR - } - Self::transferOwnership(_) => { - ::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 { - static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result] = &[ - { - fn renounceOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(OwnableCalls::renounceOwnership) - } - renounceOwnership - }, - { - fn owner(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(OwnableCalls::owner) - } - owner - }, - { - fn transferOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(OwnableCalls::transferOwnership) - } - transferOwnership - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn renounceOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(OwnableCalls::renounceOwnership) - } - renounceOwnership - }, - { - fn owner(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(OwnableCalls::owner) - } - owner - }, - { - fn transferOwnership( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(OwnableCalls::transferOwnership) - } - transferOwnership - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::owner(inner) => { - ::abi_encoded_size(inner) - } - Self::renounceOwnership(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::transferOwnership(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::owner(inner) => { - ::abi_encode_raw(inner, out) - } - Self::renounceOwnership(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::transferOwnership(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`Ownable`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum OwnableEvents { - #[allow(missing_docs)] - OwnershipTransferred(OwnershipTransferred), - } - #[automatically_derived] - impl OwnableEvents { - /// 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]] = &[ - [ - 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, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for OwnableEvents { - const NAME: &'static str = "OwnableEvents"; - const COUNT: usize = 1usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::OwnershipTransferred) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 OwnableEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::OwnershipTransferred(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::OwnershipTransferred(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`Ownable`](self) contract instance. - -See the [wrapper's documentation](`OwnableInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >(address: alloy_sol_types::private::Address, provider: P) -> OwnableInstance { - OwnableInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - OwnableInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - OwnableInstance::::deploy_builder(provider) - } - /**A [`Ownable`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`Ownable`](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 OwnableInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for OwnableInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("OwnableInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > OwnableInstance { - /**Creates a new wrapper around an on-chain [`Ownable`](self) contract instance. - -See the [wrapper's documentation](`OwnableInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 OwnableInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> OwnableInstance { - OwnableInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > OwnableInstance { - /// 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( - &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 [`owner`] function. - pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> { - self.call_builder(&ownerCall) - } - ///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. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > OwnableInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`OwnershipTransferred`] event. - pub fn OwnershipTransferred_filter( - &self, - ) -> alloy_contract::Event<&P, OwnershipTransferred, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/pell_bed_rock_lst_strategy_forked.rs b/crates/bindings/src/pell_bed_rock_lst_strategy_forked.rs deleted file mode 100644 index fd39807d7..000000000 --- a/crates/bindings/src/pell_bed_rock_lst_strategy_forked.rs +++ /dev/null @@ -1,8010 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface PellBedRockLSTStrategyForked { - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function setUp() external; - function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function testPellBedrockLSTStrategy() external; - function token() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "setUp", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "simulateForkAndTransfer", - "inputs": [ - { - "name": "forkAtBlock", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "sender", - "type": "address", - "internalType": "address" - }, - { - "name": "receiver", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testPellBedrockLSTStrategy", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "token", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IERC20" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 PellBedRockLSTStrategyForked { - use super::*; - use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15`+W__\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16t\x03\xC7\x05K\xCB9\xF7\xB2\xE5\xB2\xC7\xAC\xB3u\x83\xE3-p\xCF\xA3\0\x17\x90UaA\x9E\x80a\0a_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xFBW_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\x93W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x01\xBBW\x80c\xF9\xCE\x0EZ\x14a\x01\xC3W\x80c\xFAv&\xD4\x14a\x01\xD6W\x80c\xFC\x0CTj\x14a\x01\xE3W__\xFD[\x80c\x91j\x17\xC6\x14a\x01~W\x80c\xB0FO\xDC\x14a\x01\x93W\x80c\xB5P\x8A\xA9\x14a\x01\x9BW\x80c\xBAAO\xA6\x14a\x01\xA3W__\xFD[\x80c>^<#\x11a\0\xCEW\x80c>^<#\x14a\x01DW\x80c?r\x86\xF4\x14a\x01LW\x80cf\xD9\xA9\xA0\x14a\x01TW\x80c\x85\"l\x81\x14a\x01iW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x15\xBC\xF6[\x14a\x01\tW\x80c\x1E\xD7\x83\x1C\x14a\x01\x11W\x80c*\xDE8\x80\x14a\x01/W[__\xFD[a\x01\x07a\x02-V[\0[a\x01\x07a\x02jV[a\x01\x19a\x07)V[`@Qa\x01&\x91\x90a\x12\xFEV[`@Q\x80\x91\x03\x90\xF3[a\x017a\x07\x96V[`@Qa\x01&\x91\x90a\x13\x84V[a\x01\x19a\x08\xDFV[a\x01\x19a\tJV[a\x01\\a\t\xB5V[`@Qa\x01&\x91\x90a\x14\xD4V[a\x01qa\x0B.V[`@Qa\x01&\x91\x90a\x15RV[a\x01\x86a\x0B\xF9V[`@Qa\x01&\x91\x90a\x15\xA9V[a\x01\x86a\x0C\xFCV[a\x01qa\r\xFFV[a\x01\xABa\x0E\xCAV[`@Q\x90\x15\x15\x81R` \x01a\x01&V[a\x01\x19a\x0F\x9AV[a\x01\x07a\x01\xD16`\x04a\x16UV[a\x10\x05V[`\x1FTa\x01\xAB\x90`\xFF\x16\x81V[`\x1FTa\x02\x08\x90a\x01\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[`@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&V[a\x02hbeY\xC7sZ\x8E\x97t\xD6\x7F\xE8F\xC6\xF41\x1C\x07>*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x10\x05V[V[_sT\x1F\xD7IA\x9C\xA8\x06\xA8\xBC}\xA8\xAC#\xD3F\xF2\xDF\x8Bw\x90P_s\xCC\tf\xD8A\x8DA,Y\x9Ad!\xB7`\xA8G\xEB\x16\x9A\x8C\x90P_sI\xB0r\x15\x85d\xDB60E\x18\xFF\xA3{\x1C\xFC\x13\x91j\x90s\xBAF\xFC\xC1kFM\x97\x871Ag\xBD\xD9\xF1\xCE(@[\xA1\x7FVdR\x02@\xA4kK>\x96U\xC2\x0C\xC3\xF9\xE0\x84\x96\xA9\xB7F\xA4x\xE4v\xAE>\x04\xD6\xC8\xFC1\x7Fh\x99\xA7\xE1;e_\xA3g \x8C\xB2|n\xAA$\x107\r\x15e\xDC\x1F_\x11\x85:\x1E\x8C\xBE\xF03\x86\x86`@Qa\x03\x15\x90a\x12\xD7V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x96\x87\x16\x81R\x94\x86\x16` \x86\x01R`@\x85\x01\x93\x90\x93R``\x84\x01\x91\x90\x91R\x83\x16`\x80\x83\x01R\x90\x91\x16`\xA0\x82\x01R`\xC0\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03rW=__>=_\xFD[P\x90P_r\xB6~H\x05\x13\x83%\xCE\x87\x1D^'\xDC\x15\xF9\x94h\x1B\xC1so\n\xFA\xDE\x16\xBF\xD2\xE7\xF5QV4\xF2\xD0\xE3\xCD\x03\xC8E\xEF`@Qa\x03\xAB\x90a\x12\xE4V[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03\xE8W=__>=_\xFD[P\x90P_\x82\x82`@Qa\x03\xFA\x90a\x12\xF1V[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x047W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xB1W__\xFD[PZ\xF1\x15\x80\x15a\x04\xC3W=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x05FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05j\x91\x90a\x16\x96V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05\xFEW__\xFD[PZ\xF1\x15\x80\x15a\x06\x10W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x06mW__\xFD[PZ\xF1\x15\x80\x15a\x06\x7FW=__>=_\xFD[PP`@Q\x7Ft\xD1E\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\x81R`\x01`\x04\x82\x01Ra\x07\"\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x91Pct\xD1E\xB7\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xF0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x14\x91\x90a\x16\xBCV[g\r\xE0\xB6\xB3\xA7d\0\0a\x12TV[PPPPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07\x8CW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x07aW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x08\xBFW\x83\x82\x90_R` _ \x01\x80Ta\x084\x90a\x16\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x08`\x90a\x16\xD3V[\x80\x15a\x08\xABW\x80`\x1F\x10a\x08\x82Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x08\xABV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x08\x8EW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x08\x17V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07\xB9V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07\x8CW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x07aWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07\x8CW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x07aWPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\n\x08\x90a\x16\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n4\x90a\x16\xD3V[\x80\x15a\n\x7FW\x80`\x1F\x10a\nVWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\x7FV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\nbW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x0B\x16W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\n\xC3W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\t\xD8V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W\x83\x82\x90_R` _ \x01\x80Ta\x0Bn\x90a\x16\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\x9A\x90a\x16\xD3V[\x80\x15a\x0B\xE5W\x80`\x1F\x10a\x0B\xBCWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\xE5V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xC8W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0BQV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\xE4W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C\x91W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0C\x1CV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\xE7W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\x94W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\r\x1FV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W\x83\x82\x90_R` _ \x01\x80Ta\x0E?\x90a\x16\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0Ek\x90a\x16\xD3V[\x80\x15a\x0E\xB6W\x80`\x1F\x10a\x0E\x8DWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0E\xB6V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0E\x99W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0E\"V[`\x08T_\x90`\xFF\x16\x15a\x0E\xE1WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0FoW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\x93\x91\x90a\x16\xBCV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07\x8CW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x07aWPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\xA0W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x10\xC7\x91\x90\x81\x01\x90a\x17QV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x10\xE5\x92\x91\x90a\x18\x05V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11\x01W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11%\x91\x90a\x16\xBCV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x11\x9EW__\xFD[PZ\xF1\x15\x80\x15a\x11\xB0W=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x120W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\"\x91\x90a\x16\x96V[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x12\xBDW__\xFD[PZ\xFA\x15\x80\x15a\x12\xCFW=__>=_\xFD[PPPPPPV[a\x0F-\x80a\x18'\x839\x01\x90V[a\x0C\xF5\x80a'T\x839\x01\x90V[a\r \x80a4I\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x13KW\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\x13\x17V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14lW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x14RW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x14<\x84\x86Qa\x13VV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x14\x02V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x13\xAAV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x14\xCAW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x14\x8AV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14lW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x15 `@\x88\x01\x82a\x13VV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x15;\x81\x83a\x14xV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\xFAV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14lW`?\x19\x87\x86\x03\x01\x84Ra\x15\x94\x85\x83Qa\x13VV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15xV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14lW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x16\x17`@\x87\x01\x82a\x14xV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\xCFV[\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\x16PW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x16hW__\xFD[\x845\x93Pa\x16x` \x86\x01a\x16-V[\x92Pa\x16\x86`@\x86\x01a\x16-V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[_` \x82\x84\x03\x12\x15a\x16\xA6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x16\xB5W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x16\xCCW__\xFD[PQ\x91\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x16\xE7W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x17\x1EW\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[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\x17aW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17wW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x17\x87W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17\xA1Wa\x17\xA1a\x17$V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x17\xD1Wa\x17\xD1a\x17$V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x17\xE8W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x18\x17`@\x83\x01\x85a\x13VV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFEa\x01@`@R4\x80\x15a\0\x10W__\xFD[P`@Qa\x0F-8\x03\x80a\x0F-\x839\x81\x01`@\x81\x90Ra\0/\x91a\0sV[`\x01`\x01`\xA0\x1B\x03\x95\x86\x16`\x80R\x93\x85\x16`\xA0R`\xC0\x92\x90\x92R`\xE0R\x82\x16a\x01\0R\x16a\x01 Ra\0\xE3V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0pW__\xFD[PV[______`\xC0\x87\x89\x03\x12\x15a\0\x88W__\xFD[\x86Qa\0\x93\x81a\0\\V[` \x88\x01Q\x90\x96Pa\0\xA4\x81a\0\\V[`@\x88\x01Q``\x89\x01Q`\x80\x8A\x01Q\x92\x97P\x90\x95P\x93Pa\0\xC4\x81a\0\\V[`\xA0\x88\x01Q\x90\x92Pa\0\xD5\x81a\0\\V[\x80\x91PP\x92\x95P\x92\x95P\x92\x95V[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\r\xC6a\x01g_9_\x81\x81a\x01.\x01R\x81\x81a\x04\xFC\x01Ra\x05>\x01R_\x81\x81a\x01U\x01Ra\x03R\x01R_\x81\x81a\x01\xB1\x01Ra\x03\xC1\x01R_\x81\x81a\x01|\x01Ra\x02\x88\x01R_\x81\x81`\xDF\x01R\x81\x81a\x03t\x01Ra\x03\xF0\x01R_\x81\x81`\x8E\x01R\x81\x81a\x02;\x01Ra\x02\xB7\x01Ra\r\xC6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\x85W_5`\xE0\x1C\x80c\xADt}\xE6\x11a\0XW\x80c\xADt}\xE6\x14a\x01)W\x80c\xB9\x93|\xCB\x14a\x01PW\x80c\xC8\xC7\xF7\x01\x14a\x01wW\x80c\xE3L\xEF\x86\x14a\x01\xACW__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0\x89W\x80cN=\xF3\xF4\x14a\0\xDAW\x80cPcL\x0E\x14a\x01\x01W\x80c\x7F\x81O5\x14a\x01\x16W[__\xFD[a\0\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\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\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\x81V[a\x01\x14a\x01\x0F6`\x04a\x0BgV[a\x01\xD3V[\0[a\x01\x14a\x01$6`\x04a\x0C)V[a\x01\xFDV[a\0\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\x81V[a\0\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\x81V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xD1V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\xE8\x91\x90a\x0C\xADV[\x90Pa\x01\xF6\x85\x85\x85\x84a\x01\xFDV[PPPPPV[a\x02\x1Fs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x9AV[a\x02`s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x036\x91\x90a\x0C\xD1V[\x90Pa\x03\x99s\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\x7F\0\0\0\0\0\0\0\0\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\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x82\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04KW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04o\x91\x90a\x0C\xD1V[\x83Q\x90\x91P\x81\x10\x15a\x04\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[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\x85\x83a\x07YV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x06X\x90\x85\x90\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\x90`\x84\x01[`@\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\x07\xB4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF6\x91\x90a\x0C\xD1V[a\x07\0\x91\x90a\x0C\xE8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x06X\x90\x85\x90\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\x90`d\x01a\x05\xF4V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07\xAF\x90\x84\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\x90`d\x01a\x05\xF4V[PPPV[_a\x08\x15\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\x08\xBF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\xAFW\x80\x80` \x01\x90Q\x81\x01\x90a\x083\x91\x90a\r&V[a\x07\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\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\x04\xD9V[``a\x08\xCD\x84\x84_\x85a\x08\xD7V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\tiW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x04\xD9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\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`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x04\xD9V[__\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\n\x0F\x91\x90a\rEV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\nIW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\nNV[``\x91P[P\x91P\x91Pa\n^\x82\x82\x86a\niV[\x97\x96PPPPPPPV[``\x83\x15a\nxWP\x81a\x08\xD0V[\x82Q\x15a\n\x88W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x04\xD9\x91\x90a\r[V[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\xDDW__\xFD[PV[\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\x0B0Wa\x0B0a\n\xE0V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0B_Wa\x0B_a\n\xE0V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0BzW__\xFD[\x845a\x0B\x85\x81a\n\xBCV[\x93P` \x85\x015\x92P`@\x85\x015a\x0B\x9C\x81a\n\xBCV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xB7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\x0B\xC7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xE1Wa\x0B\xE1a\n\xE0V[a\x0B\xF4` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0B6V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0C\x08W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0C=W__\xFD[\x855a\x0CH\x81a\n\xBCV[\x94P` \x86\x015\x93P`@\x86\x015a\x0C_\x81a\n\xBCV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0C\x90W__\xFD[Pa\x0C\x99a\x0B\rV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0C\xBEW__\xFD[Pa\x0C\xC7a\x0B\rV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C\xE1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\r 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[_` \x82\x84\x03\x12\x15a\r6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x08\xD0W__\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\xFE\xA2dipfsX\"\x12 \xD28\x8C\xB3\xDCz\xA6\xF5\xA2\xEBuA}\x11\x05\x9B\xE1<\x8C\x9E\xAB\xE5\xD7\xEA\xDB\x1BV\x1F\x93\x7F\xF6\x91dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x0C\xF58\x03\x80a\x0C\xF5\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\x1Ea\0\xD7_9_\x81\x81`\xBB\x01R\x81\x81a\x01\x98\x01Ra\x02\xDB\x01R_\x81\x81a\x01\x07\x01R\x81\x81a\x01\xC2\x01R\x81\x81a\x02q\x01Ra\x03\x14\x01Ra\x0C\x1E_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0dW_5`\xE0\x1C\x80c\x7F\x81O5\x11a\0MW\x80c\x7F\x81O5\x14a\0\xA3W\x80c\xA6\xAA\x9C\xC0\x14a\0\xB6W\x80c\xC9F\x1AD\x14a\x01\x02W__\xFD[\x80cPcL\x0E\x14a\0hW\x80ct\xD1E\xB7\x14a\0}W[__\xFD[a\0{a\0v6`\x04a\t\xAAV[a\x01)V[\0[a\0\x90a\0\x8B6`\x04a\nlV[a\x01SV[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0{a\0\xB16`\x04a\n\x87V[a\x023V[a\0\xDD\x7F\0\0\0\0\0\0\0\0\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\0\x9AV[a\0\xDD\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01>\x91\x90a\x0B\x0BV[\x90Pa\x01L\x85\x85\x85\x84a\x023V[PPPPPV[`@Q\x7Fz~\r\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\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\x7F\0\0\0\0\0\0\0\0\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`$\x83\x01R_\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\x90\x91\x16\x90cz~\r\x92\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\tW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02-\x91\x90a\x0B/V[\x92\x91PPV[a\x02Us\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x043V[a\x02\x96s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\xF7V[`@Q\x7F\xE4hB\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\x83\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\x81\x16`$\x83\x01R\x85\x81\x16`D\x83\x01R`d\x82\x01\x85\x90R_\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\x90\x91\x16\x90c\xE4hB\xB7\x90`\x84\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\\W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x80\x91\x90a\x0B/V[\x82Q\x90\x91P\x81\x10\x15a\x03\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q_\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xF1\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xF2V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05kW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x8F\x91\x90a\x0B/V[a\x05\x99\x91\x90a\x0BFV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xF1\x90\x85\x90\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\x90`d\x01a\x04\x8DV[_a\x06S\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\x07\x02\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\xFDW\x80\x80` \x01\x90Q\x81\x01\x90a\x06q\x91\x90a\x0B~V[a\x06\xFDW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[PPPV[``a\x07\x10\x84\x84_\x85a\x07\x1AV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xACW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08*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\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x03\xEAV[__\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\x08R\x91\x90a\x0B\x9DV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x8CW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x91V[``\x91P[P\x91P\x91Pa\x08\xA1\x82\x82\x86a\x08\xACV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xBBWP\x81a\x07\x13V[\x82Q\x15a\x08\xCBW\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\xEA\x91\x90a\x0B\xB3V[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\t W__\xFD[PV[\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\tsWa\tsa\t#V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xA2Wa\t\xA2a\t#V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xBDW__\xFD[\x845a\t\xC8\x81a\x08\xFFV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xDF\x81a\x08\xFFV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xFAW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\nW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n$Wa\n$a\t#V[a\n7` `\x1F\x19`\x1F\x84\x01\x16\x01a\tyV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nKW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[_` \x82\x84\x03\x12\x15a\n|W__\xFD[\x815a\x07\x13\x81a\x08\xFFV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x9BW__\xFD[\x855a\n\xA6\x81a\x08\xFFV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xBD\x81a\x08\xFFV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xEEW__\xFD[Pa\n\xF7a\tPV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x1CW__\xFD[Pa\x0B%a\tPV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B?W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02-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[_` \x82\x84\x03\x12\x15a\x0B\x8EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x13W__\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\xFE\xA2dipfsX\"\x12 1\xA9_\tS$\x80\xC4eD\\\xF1\xA5F\x84\x08w?\xBD\x88\xEC\xC5\xCAl\x9C\xCA\x82\xDE\xCAb4\x08dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r 8\x03\x80a\r \x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CJa\0\xD6_9_\x81\x81`{\x01R\x81\x81a\x03u\x01Ra\x03\xF5\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0CJ_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cPcL\x0E\x14a\0NW\x80c\x7F\x81O5\x14a\0cW\x80c\xA6\xAA\x9C\xC0\x14a\0vW\x80c\xF2#L\xF9\x14a\0\xC6W[__\xFD[a\0aa\0\\6`\x04a\t\xD0V[a\0\xEDV[\0[a\0aa\0q6`\x04a\n\x92V[a\x01\x17V[a\0\x9D\x7F\0\0\0\0\0\0\0\0\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\x9D\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 ;\xBE\xA4\0\nXD\x11.v'\xBB\xE5\xECgi\x01\x98\xF0\xDF\xD9,\xA6^&\r\xB6\x93\x85\x0Bf\xA8dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 (\x9F\xC0L\xB8\xC0\x0E\x14\xCF\xB1\x04\xF5\xC8F\xD3\x8C\xA3\x05\x19Y:K\x02\xB7\xCF\xD6~\x1B\xA9\x96\xC7JdsolcC\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\0\xFBW_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\x93W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x01\xBBW\x80c\xF9\xCE\x0EZ\x14a\x01\xC3W\x80c\xFAv&\xD4\x14a\x01\xD6W\x80c\xFC\x0CTj\x14a\x01\xE3W__\xFD[\x80c\x91j\x17\xC6\x14a\x01~W\x80c\xB0FO\xDC\x14a\x01\x93W\x80c\xB5P\x8A\xA9\x14a\x01\x9BW\x80c\xBAAO\xA6\x14a\x01\xA3W__\xFD[\x80c>^<#\x11a\0\xCEW\x80c>^<#\x14a\x01DW\x80c?r\x86\xF4\x14a\x01LW\x80cf\xD9\xA9\xA0\x14a\x01TW\x80c\x85\"l\x81\x14a\x01iW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x15\xBC\xF6[\x14a\x01\tW\x80c\x1E\xD7\x83\x1C\x14a\x01\x11W\x80c*\xDE8\x80\x14a\x01/W[__\xFD[a\x01\x07a\x02-V[\0[a\x01\x07a\x02jV[a\x01\x19a\x07)V[`@Qa\x01&\x91\x90a\x12\xFEV[`@Q\x80\x91\x03\x90\xF3[a\x017a\x07\x96V[`@Qa\x01&\x91\x90a\x13\x84V[a\x01\x19a\x08\xDFV[a\x01\x19a\tJV[a\x01\\a\t\xB5V[`@Qa\x01&\x91\x90a\x14\xD4V[a\x01qa\x0B.V[`@Qa\x01&\x91\x90a\x15RV[a\x01\x86a\x0B\xF9V[`@Qa\x01&\x91\x90a\x15\xA9V[a\x01\x86a\x0C\xFCV[a\x01qa\r\xFFV[a\x01\xABa\x0E\xCAV[`@Q\x90\x15\x15\x81R` \x01a\x01&V[a\x01\x19a\x0F\x9AV[a\x01\x07a\x01\xD16`\x04a\x16UV[a\x10\x05V[`\x1FTa\x01\xAB\x90`\xFF\x16\x81V[`\x1FTa\x02\x08\x90a\x01\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[`@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&V[a\x02hbeY\xC7sZ\x8E\x97t\xD6\x7F\xE8F\xC6\xF41\x1C\x07>*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x10\x05V[V[_sT\x1F\xD7IA\x9C\xA8\x06\xA8\xBC}\xA8\xAC#\xD3F\xF2\xDF\x8Bw\x90P_s\xCC\tf\xD8A\x8DA,Y\x9Ad!\xB7`\xA8G\xEB\x16\x9A\x8C\x90P_sI\xB0r\x15\x85d\xDB60E\x18\xFF\xA3{\x1C\xFC\x13\x91j\x90s\xBAF\xFC\xC1kFM\x97\x871Ag\xBD\xD9\xF1\xCE(@[\xA1\x7FVdR\x02@\xA4kK>\x96U\xC2\x0C\xC3\xF9\xE0\x84\x96\xA9\xB7F\xA4x\xE4v\xAE>\x04\xD6\xC8\xFC1\x7Fh\x99\xA7\xE1;e_\xA3g \x8C\xB2|n\xAA$\x107\r\x15e\xDC\x1F_\x11\x85:\x1E\x8C\xBE\xF03\x86\x86`@Qa\x03\x15\x90a\x12\xD7V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x96\x87\x16\x81R\x94\x86\x16` \x86\x01R`@\x85\x01\x93\x90\x93R``\x84\x01\x91\x90\x91R\x83\x16`\x80\x83\x01R\x90\x91\x16`\xA0\x82\x01R`\xC0\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03rW=__>=_\xFD[P\x90P_r\xB6~H\x05\x13\x83%\xCE\x87\x1D^'\xDC\x15\xF9\x94h\x1B\xC1so\n\xFA\xDE\x16\xBF\xD2\xE7\xF5QV4\xF2\xD0\xE3\xCD\x03\xC8E\xEF`@Qa\x03\xAB\x90a\x12\xE4V[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03\xE8W=__>=_\xFD[P\x90P_\x82\x82`@Qa\x03\xFA\x90a\x12\xF1V[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x047W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xB1W__\xFD[PZ\xF1\x15\x80\x15a\x04\xC3W=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x05FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05j\x91\x90a\x16\x96V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05\xFEW__\xFD[PZ\xF1\x15\x80\x15a\x06\x10W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x06mW__\xFD[PZ\xF1\x15\x80\x15a\x06\x7FW=__>=_\xFD[PP`@Q\x7Ft\xD1E\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\x81R`\x01`\x04\x82\x01Ra\x07\"\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x91Pct\xD1E\xB7\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xF0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\x14\x91\x90a\x16\xBCV[g\r\xE0\xB6\xB3\xA7d\0\0a\x12TV[PPPPPV[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07\x8CW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x07aW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x08\xBFW\x83\x82\x90_R` _ \x01\x80Ta\x084\x90a\x16\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x08`\x90a\x16\xD3V[\x80\x15a\x08\xABW\x80`\x1F\x10a\x08\x82Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x08\xABV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x08\x8EW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x08\x17V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07\xB9V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07\x8CW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x07aWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07\x8CW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x07aWPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\n\x08\x90a\x16\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n4\x90a\x16\xD3V[\x80\x15a\n\x7FW\x80`\x1F\x10a\nVWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\x7FV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\nbW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x0B\x16W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\n\xC3W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\t\xD8V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W\x83\x82\x90_R` _ \x01\x80Ta\x0Bn\x90a\x16\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\x9A\x90a\x16\xD3V[\x80\x15a\x0B\xE5W\x80`\x1F\x10a\x0B\xBCWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\xE5V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xC8W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0BQV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\xE4W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C\x91W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0C\x1CV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r\xE7W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\x94W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\r\x1FV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x08\xD6W\x83\x82\x90_R` _ \x01\x80Ta\x0E?\x90a\x16\xD3V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0Ek\x90a\x16\xD3V[\x80\x15a\x0E\xB6W\x80`\x1F\x10a\x0E\x8DWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0E\xB6V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0E\x99W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0E\"V[`\x08T_\x90`\xFF\x16\x15a\x0E\xE1WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0FoW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\x93\x91\x90a\x16\xBCV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x07\x8CW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x07aWPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\xA0W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x10\xC7\x91\x90\x81\x01\x90a\x17QV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x10\xE5\x92\x91\x90a\x18\x05V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11\x01W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11%\x91\x90a\x16\xBCV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x11\x9EW__\xFD[PZ\xF1\x15\x80\x15a\x11\xB0W=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x120W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\"\x91\x90a\x16\x96V[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x12\xBDW__\xFD[PZ\xFA\x15\x80\x15a\x12\xCFW=__>=_\xFD[PPPPPPV[a\x0F-\x80a\x18'\x839\x01\x90V[a\x0C\xF5\x80a'T\x839\x01\x90V[a\r \x80a4I\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x13KW\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\x13\x17V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14lW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x14RW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x14<\x84\x86Qa\x13VV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x14\x02V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x13\xAAV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x14\xCAW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x14\x8AV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14lW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x15 `@\x88\x01\x82a\x13VV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x15;\x81\x83a\x14xV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\xFAV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14lW`?\x19\x87\x86\x03\x01\x84Ra\x15\x94\x85\x83Qa\x13VV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15xV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x14lW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x16\x17`@\x87\x01\x82a\x14xV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15\xCFV[\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\x16PW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x16hW__\xFD[\x845\x93Pa\x16x` \x86\x01a\x16-V[\x92Pa\x16\x86`@\x86\x01a\x16-V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[_` \x82\x84\x03\x12\x15a\x16\xA6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x16\xB5W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x16\xCCW__\xFD[PQ\x91\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x16\xE7W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x17\x1EW\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[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\x17aW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17wW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x17\x87W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x17\xA1Wa\x17\xA1a\x17$V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x17\xD1Wa\x17\xD1a\x17$V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x17\xE8W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x18\x17`@\x83\x01\x85a\x13VV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFEa\x01@`@R4\x80\x15a\0\x10W__\xFD[P`@Qa\x0F-8\x03\x80a\x0F-\x839\x81\x01`@\x81\x90Ra\0/\x91a\0sV[`\x01`\x01`\xA0\x1B\x03\x95\x86\x16`\x80R\x93\x85\x16`\xA0R`\xC0\x92\x90\x92R`\xE0R\x82\x16a\x01\0R\x16a\x01 Ra\0\xE3V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0pW__\xFD[PV[______`\xC0\x87\x89\x03\x12\x15a\0\x88W__\xFD[\x86Qa\0\x93\x81a\0\\V[` \x88\x01Q\x90\x96Pa\0\xA4\x81a\0\\V[`@\x88\x01Q``\x89\x01Q`\x80\x8A\x01Q\x92\x97P\x90\x95P\x93Pa\0\xC4\x81a\0\\V[`\xA0\x88\x01Q\x90\x92Pa\0\xD5\x81a\0\\V[\x80\x91PP\x92\x95P\x92\x95P\x92\x95V[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\r\xC6a\x01g_9_\x81\x81a\x01.\x01R\x81\x81a\x04\xFC\x01Ra\x05>\x01R_\x81\x81a\x01U\x01Ra\x03R\x01R_\x81\x81a\x01\xB1\x01Ra\x03\xC1\x01R_\x81\x81a\x01|\x01Ra\x02\x88\x01R_\x81\x81`\xDF\x01R\x81\x81a\x03t\x01Ra\x03\xF0\x01R_\x81\x81`\x8E\x01R\x81\x81a\x02;\x01Ra\x02\xB7\x01Ra\r\xC6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\x85W_5`\xE0\x1C\x80c\xADt}\xE6\x11a\0XW\x80c\xADt}\xE6\x14a\x01)W\x80c\xB9\x93|\xCB\x14a\x01PW\x80c\xC8\xC7\xF7\x01\x14a\x01wW\x80c\xE3L\xEF\x86\x14a\x01\xACW__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0\x89W\x80cN=\xF3\xF4\x14a\0\xDAW\x80cPcL\x0E\x14a\x01\x01W\x80c\x7F\x81O5\x14a\x01\x16W[__\xFD[a\0\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\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\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\x81V[a\x01\x14a\x01\x0F6`\x04a\x0BgV[a\x01\xD3V[\0[a\x01\x14a\x01$6`\x04a\x0C)V[a\x01\xFDV[a\0\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\x81V[a\0\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\x81V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xD1V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\xE8\x91\x90a\x0C\xADV[\x90Pa\x01\xF6\x85\x85\x85\x84a\x01\xFDV[PPPPPV[a\x02\x1Fs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x9AV[a\x02`s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x036\x91\x90a\x0C\xD1V[\x90Pa\x03\x99s\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\x7F\0\0\0\0\0\0\0\0\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\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x82\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04KW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04o\x91\x90a\x0C\xD1V[\x83Q\x90\x91P\x81\x10\x15a\x04\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[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\x85\x83a\x07YV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x06X\x90\x85\x90\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\x90`\x84\x01[`@\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\x07\xB4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF6\x91\x90a\x0C\xD1V[a\x07\0\x91\x90a\x0C\xE8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x06X\x90\x85\x90\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\x90`d\x01a\x05\xF4V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07\xAF\x90\x84\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\x90`d\x01a\x05\xF4V[PPPV[_a\x08\x15\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\x08\xBF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\xAFW\x80\x80` \x01\x90Q\x81\x01\x90a\x083\x91\x90a\r&V[a\x07\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\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\x04\xD9V[``a\x08\xCD\x84\x84_\x85a\x08\xD7V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\tiW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x04\xD9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\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`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x04\xD9V[__\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\n\x0F\x91\x90a\rEV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\nIW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\nNV[``\x91P[P\x91P\x91Pa\n^\x82\x82\x86a\niV[\x97\x96PPPPPPPV[``\x83\x15a\nxWP\x81a\x08\xD0V[\x82Q\x15a\n\x88W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x04\xD9\x91\x90a\r[V[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\xDDW__\xFD[PV[\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\x0B0Wa\x0B0a\n\xE0V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0B_Wa\x0B_a\n\xE0V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0BzW__\xFD[\x845a\x0B\x85\x81a\n\xBCV[\x93P` \x85\x015\x92P`@\x85\x015a\x0B\x9C\x81a\n\xBCV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xB7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\x0B\xC7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xE1Wa\x0B\xE1a\n\xE0V[a\x0B\xF4` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0B6V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0C\x08W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0C=W__\xFD[\x855a\x0CH\x81a\n\xBCV[\x94P` \x86\x015\x93P`@\x86\x015a\x0C_\x81a\n\xBCV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0C\x90W__\xFD[Pa\x0C\x99a\x0B\rV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0C\xBEW__\xFD[Pa\x0C\xC7a\x0B\rV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C\xE1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\r 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[_` \x82\x84\x03\x12\x15a\r6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x08\xD0W__\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\xFE\xA2dipfsX\"\x12 \xD28\x8C\xB3\xDCz\xA6\xF5\xA2\xEBuA}\x11\x05\x9B\xE1<\x8C\x9E\xAB\xE5\xD7\xEA\xDB\x1BV\x1F\x93\x7F\xF6\x91dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x0C\xF58\x03\x80a\x0C\xF5\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\x1Ea\0\xD7_9_\x81\x81`\xBB\x01R\x81\x81a\x01\x98\x01Ra\x02\xDB\x01R_\x81\x81a\x01\x07\x01R\x81\x81a\x01\xC2\x01R\x81\x81a\x02q\x01Ra\x03\x14\x01Ra\x0C\x1E_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0dW_5`\xE0\x1C\x80c\x7F\x81O5\x11a\0MW\x80c\x7F\x81O5\x14a\0\xA3W\x80c\xA6\xAA\x9C\xC0\x14a\0\xB6W\x80c\xC9F\x1AD\x14a\x01\x02W__\xFD[\x80cPcL\x0E\x14a\0hW\x80ct\xD1E\xB7\x14a\0}W[__\xFD[a\0{a\0v6`\x04a\t\xAAV[a\x01)V[\0[a\0\x90a\0\x8B6`\x04a\nlV[a\x01SV[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0{a\0\xB16`\x04a\n\x87V[a\x023V[a\0\xDD\x7F\0\0\0\0\0\0\0\0\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\0\x9AV[a\0\xDD\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01>\x91\x90a\x0B\x0BV[\x90Pa\x01L\x85\x85\x85\x84a\x023V[PPPPPV[`@Q\x7Fz~\r\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\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\x7F\0\0\0\0\0\0\0\0\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`$\x83\x01R_\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\x90\x91\x16\x90cz~\r\x92\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\tW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02-\x91\x90a\x0B/V[\x92\x91PPV[a\x02Us\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x043V[a\x02\x96s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\xF7V[`@Q\x7F\xE4hB\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\x83\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\x81\x16`$\x83\x01R\x85\x81\x16`D\x83\x01R`d\x82\x01\x85\x90R_\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\x90\x91\x16\x90c\xE4hB\xB7\x90`\x84\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\\W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x80\x91\x90a\x0B/V[\x82Q\x90\x91P\x81\x10\x15a\x03\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q_\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xF1\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xF2V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05kW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x8F\x91\x90a\x0B/V[a\x05\x99\x91\x90a\x0BFV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xF1\x90\x85\x90\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\x90`d\x01a\x04\x8DV[_a\x06S\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\x07\x02\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\xFDW\x80\x80` \x01\x90Q\x81\x01\x90a\x06q\x91\x90a\x0B~V[a\x06\xFDW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[PPPV[``a\x07\x10\x84\x84_\x85a\x07\x1AV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xACW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08*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\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x03\xEAV[__\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\x08R\x91\x90a\x0B\x9DV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x8CW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x91V[``\x91P[P\x91P\x91Pa\x08\xA1\x82\x82\x86a\x08\xACV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xBBWP\x81a\x07\x13V[\x82Q\x15a\x08\xCBW\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\xEA\x91\x90a\x0B\xB3V[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\t W__\xFD[PV[\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\tsWa\tsa\t#V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xA2Wa\t\xA2a\t#V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xBDW__\xFD[\x845a\t\xC8\x81a\x08\xFFV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xDF\x81a\x08\xFFV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xFAW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\nW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n$Wa\n$a\t#V[a\n7` `\x1F\x19`\x1F\x84\x01\x16\x01a\tyV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nKW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[_` \x82\x84\x03\x12\x15a\n|W__\xFD[\x815a\x07\x13\x81a\x08\xFFV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x9BW__\xFD[\x855a\n\xA6\x81a\x08\xFFV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xBD\x81a\x08\xFFV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xEEW__\xFD[Pa\n\xF7a\tPV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x1CW__\xFD[Pa\x0B%a\tPV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B?W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02-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[_` \x82\x84\x03\x12\x15a\x0B\x8EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x13W__\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\xFE\xA2dipfsX\"\x12 1\xA9_\tS$\x80\xC4eD\\\xF1\xA5F\x84\x08w?\xBD\x88\xEC\xC5\xCAl\x9C\xCA\x82\xDE\xCAb4\x08dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r 8\x03\x80a\r \x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CJa\0\xD6_9_\x81\x81`{\x01R\x81\x81a\x03u\x01Ra\x03\xF5\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0CJ_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cPcL\x0E\x14a\0NW\x80c\x7F\x81O5\x14a\0cW\x80c\xA6\xAA\x9C\xC0\x14a\0vW\x80c\xF2#L\xF9\x14a\0\xC6W[__\xFD[a\0aa\0\\6`\x04a\t\xD0V[a\0\xEDV[\0[a\0aa\0q6`\x04a\n\x92V[a\x01\x17V[a\0\x9D\x7F\0\0\0\0\0\0\0\0\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\x9D\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 ;\xBE\xA4\0\nXD\x11.v'\xBB\xE5\xECgi\x01\x98\xF0\xDF\xD9,\xA6^&\r\xB6\x93\x85\x0Bf\xA8dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 (\x9F\xC0L\xB8\xC0\x0E\x14\xCF\xB1\x04\xF5\xC8F\xD3\x8C\xA3\x05\x19Y:K\x02\xB7\xCF\xD6~\x1B\xA9\x96\xC7JdsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. -```solidity -event log(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `setUp()` and selector `0x0a9254e4`. -```solidity -function setUp() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setUpCall; - ///Container type for the return parameters of the [`setUp()`](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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl setUpReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for setUpCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = setUpReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "setUp()"; - const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - setUpReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. -```solidity -function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferCall { - #[allow(missing_docs)] - pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub sender: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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::Uint<256>, - ); - #[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::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferCall) -> Self { - (value.forkAtBlock, value.sender, value.receiver, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - forkAtBlock: tuple.0, - sender: tuple.1, - receiver: tuple.2, - amount: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl simulateForkAndTransferReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for simulateForkAndTransferCall { - type Parameters<'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::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = simulateForkAndTransferReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; - const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), - ::tokenize( - &self.sender, - ), - ::tokenize( - &self.receiver, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - simulateForkAndTransferReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testPellBedrockLSTStrategy()` and selector `0x15bcf65b`. -```solidity -function testPellBedrockLSTStrategy() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testPellBedrockLSTStrategyCall; - ///Container type for the return parameters of the [`testPellBedrockLSTStrategy()`](testPellBedrockLSTStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testPellBedrockLSTStrategyReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testPellBedrockLSTStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testPellBedrockLSTStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testPellBedrockLSTStrategyReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testPellBedrockLSTStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testPellBedrockLSTStrategyReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testPellBedrockLSTStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testPellBedrockLSTStrategyReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testPellBedrockLSTStrategy()"; - const SELECTOR: [u8; 4] = [21u8, 188u8, 246u8, 91u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testPellBedrockLSTStrategyReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `token()` and selector `0xfc0c546a`. -```solidity -function token() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`token()`](tokenCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for tokenCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "token()"; - const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`PellBedRockLSTStrategyForked`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum PellBedRockLSTStrategyForkedCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - setUp(setUpCall), - #[allow(missing_docs)] - simulateForkAndTransfer(simulateForkAndTransferCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - testPellBedrockLSTStrategy(testPellBedrockLSTStrategyCall), - #[allow(missing_docs)] - token(tokenCall), - } - #[automatically_derived] - impl PellBedRockLSTStrategyForkedCalls { - /// 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]] = &[ - [10u8, 146u8, 84u8, 228u8], - [21u8, 188u8, 246u8, 91u8], - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [102u8, 217u8, 169u8, 160u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [226u8, 12u8, 159u8, 113u8], - [249u8, 206u8, 14u8, 90u8], - [250u8, 118u8, 38u8, 212u8], - [252u8, 12u8, 84u8, 106u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for PellBedRockLSTStrategyForkedCalls { - const NAME: &'static str = "PellBedRockLSTStrategyForkedCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 16usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::setUp(_) => ::SELECTOR, - Self::simulateForkAndTransfer(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::testPellBedrockLSTStrategy(_) => { - ::SELECTOR - } - Self::token(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(PellBedRockLSTStrategyForkedCalls::setUp) - } - setUp - }, - { - fn testPellBedrockLSTStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - PellBedRockLSTStrategyForkedCalls::testPellBedrockLSTStrategy, - ) - } - testPellBedrockLSTStrategy - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedRockLSTStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedRockLSTStrategyForkedCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedRockLSTStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedRockLSTStrategyForkedCalls::targetContracts) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - PellBedRockLSTStrategyForkedCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedRockLSTStrategyForkedCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedRockLSTStrategyForkedCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedRockLSTStrategyForkedCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedRockLSTStrategyForkedCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(PellBedRockLSTStrategyForkedCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedRockLSTStrategyForkedCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - PellBedRockLSTStrategyForkedCalls::simulateForkAndTransfer, - ) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(PellBedRockLSTStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(PellBedRockLSTStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockLSTStrategyForkedCalls::setUp) - } - setUp - }, - { - fn testPellBedrockLSTStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - PellBedRockLSTStrategyForkedCalls::testPellBedrockLSTStrategy, - ) - } - testPellBedrockLSTStrategy - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockLSTStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockLSTStrategyForkedCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockLSTStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockLSTStrategyForkedCalls::targetContracts) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - PellBedRockLSTStrategyForkedCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockLSTStrategyForkedCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockLSTStrategyForkedCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockLSTStrategyForkedCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockLSTStrategyForkedCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockLSTStrategyForkedCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockLSTStrategyForkedCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - PellBedRockLSTStrategyForkedCalls::simulateForkAndTransfer, - ) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockLSTStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockLSTStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::setUp(inner) => { - ::abi_encoded_size(inner) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testPellBedrockLSTStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::token(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::setUp(inner) => { - ::abi_encode_raw(inner, out) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testPellBedrockLSTStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::token(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - ///Container for all the [`PellBedRockLSTStrategyForked`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum PellBedRockLSTStrategyForkedEvents { - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl PellBedRockLSTStrategyForkedEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for PellBedRockLSTStrategyForkedEvents { - const NAME: &'static str = "PellBedRockLSTStrategyForkedEvents"; - const COUNT: usize = 22usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 PellBedRockLSTStrategyForkedEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`PellBedRockLSTStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`PellBedRockLSTStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> PellBedRockLSTStrategyForkedInstance { - PellBedRockLSTStrategyForkedInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - PellBedRockLSTStrategyForkedInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - PellBedRockLSTStrategyForkedInstance::::deploy_builder(provider) - } - /**A [`PellBedRockLSTStrategyForked`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`PellBedRockLSTStrategyForked`](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 PellBedRockLSTStrategyForkedInstance< - P, - N = alloy_contract::private::Ethereum, - > { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for PellBedRockLSTStrategyForkedInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("PellBedRockLSTStrategyForkedInstance") - .field(&self.address) - .finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PellBedRockLSTStrategyForkedInstance { - /**Creates a new wrapper around an on-chain [`PellBedRockLSTStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`PellBedRockLSTStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 PellBedRockLSTStrategyForkedInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> PellBedRockLSTStrategyForkedInstance { - PellBedRockLSTStrategyForkedInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PellBedRockLSTStrategyForkedInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`setUp`] function. - pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { - self.call_builder(&setUpCall) - } - ///Creates a new call builder for the [`simulateForkAndTransfer`] function. - pub fn simulateForkAndTransfer( - &self, - forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - sender: alloy::sol_types::private::Address, - receiver: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { - self.call_builder( - &simulateForkAndTransferCall { - forkAtBlock, - sender, - receiver, - amount, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`testPellBedrockLSTStrategy`] function. - pub fn testPellBedrockLSTStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testPellBedrockLSTStrategyCall, N> { - self.call_builder(&testPellBedrockLSTStrategyCall) - } - ///Creates a new call builder for the [`token`] function. - pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { - self.call_builder(&tokenCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PellBedRockLSTStrategyForkedInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/pell_bed_rock_strategy_forked.rs b/crates/bindings/src/pell_bed_rock_strategy_forked.rs deleted file mode 100644 index 13b114c3a..000000000 --- a/crates/bindings/src/pell_bed_rock_strategy_forked.rs +++ /dev/null @@ -1,7998 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface PellBedRockStrategyForked { - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function setUp() external; - function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function testPellBedrockStrategy() external; - function token() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "setUp", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "simulateForkAndTransfer", - "inputs": [ - { - "name": "forkAtBlock", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "sender", - "type": "address", - "internalType": "address" - }, - { - "name": "receiver", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testPellBedrockStrategy", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "token", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IERC20" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 PellBedRockStrategyForked { - use super::*; - use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15`+W__\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16t\x03\xC7\x05K\xCB9\xF7\xB2\xE5\xB2\xC7\xAC\xB3u\x83\xE3-p\xCF\xA3\0\x17\x90Ua?\x07\x80a\0a_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xFBW_5`\xE0\x1C\x80c\x95\x90&i\x11a\0\x93W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x01\xBBW\x80c\xF9\xCE\x0EZ\x14a\x01\xC3W\x80c\xFAv&\xD4\x14a\x01\xD6W\x80c\xFC\x0CTj\x14a\x01\xE3W__\xFD[\x80c\x95\x90&i\x14a\x01\x8BW\x80c\xB0FO\xDC\x14a\x01\x93W\x80c\xB5P\x8A\xA9\x14a\x01\x9BW\x80c\xBAAO\xA6\x14a\x01\xA3W__\xFD[\x80c?r\x86\xF4\x11a\0\xCEW\x80c?r\x86\xF4\x14a\x01DW\x80cf\xD9\xA9\xA0\x14a\x01LW\x80c\x85\"l\x81\x14a\x01aW\x80c\x91j\x17\xC6\x14a\x01vW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x1E\xD7\x83\x1C\x14a\x01\tW\x80c*\xDE8\x80\x14a\x01'W\x80c>^<#\x14a\x01*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x0FTV[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\0W\x83\x82\x90_R` _ \x01\x80Ta\x03u\x90a\x15\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xA1\x90a\x15\xECV[\x80\x15a\x03\xECW\x80`\x1F\x10a\x03\xC3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xECV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xCFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03XV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xFAV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x05I\x90a\x15\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05u\x90a\x15\xECV[\x80\x15a\x05\xC0W\x80`\x1F\x10a\x05\x97Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05\xC0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05\xA3W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06WW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x06\x04W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05\x19V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\x06\xAF\x90a\x15\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06\xDB\x90a\x15\xECV[\x80\x15a\x07&W\x80`\x1F\x10a\x06\xFDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07&V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\tW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x06\x92V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x08%W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x07\xD2W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07]V[_s*\xC9\x8D\xB4\x1C\xBD1r\xCB{\x8F\xD8\xA8\xAB;\x91\xCF\xE4]\xCF\x90P_\x81`@Qa\x08c\x90a\x12-V[s\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_\xF0\x80\x15\x80\x15a\x08\x99W=__>=_\xFD[P\x90P_r\xB6~H\x05\x13\x83%\xCE\x87\x1D^'\xDC\x15\xF9\x94h\x1B\xC1sc\x1A\xE9~$\xF9\xF3\x01P\xD3\x1D\x95\x8D7\x91Yu\xF1.\xD8`@Qa\x08\xD2\x90a\x12:V[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\t\x0FW=__>=_\xFD[P\x90P_\x82\x82`@Qa\t!\x90a\x12GV[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\t^W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t\xD8W__\xFD[PZ\xF1\x15\x80\x15a\t\xEAW=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\nmW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\x91\x91\x90a\x16=V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0B%W__\xFD[PZ\xF1\x15\x80\x15a\x0B7W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0B\x94W__\xFD[PZ\xF1\x15\x80\x15a\x0B\xA6W=__>=_\xFD[PP`@Q\x7Ft\xD1E\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\x81R`\x01`\x04\x82\x01Ra\x0CE\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x91Pct\xD1E\xB7\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0C\x17W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C;\x91\x90a\x16cV[c\x05\xF5\xE1\0a\x11\xAAV[PPPPV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r6W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C\xE3W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0CnV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\r\x8E\x90a\x15\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\xBA\x90a\x15\xECV[\x80\x15a\x0E\x05W\x80`\x1F\x10a\r\xDCWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0E\x05V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r\xE8W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\rqV[`\x08T_\x90`\xFF\x16\x15a\x0E0WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\xBEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\xE2\x91\x90a\x16cV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\xEFW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x10\x16\x91\x90\x81\x01\x90a\x16\xA7V[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x104\x92\x91\x90a\x17[V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10PW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10t\x91\x90a\x16cV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10\xEDW__\xFD[PZ\xF1\x15\x80\x15a\x10\xFFW=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11\x7FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\xA3\x91\x90a\x16=V[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x12\x13W__\xFD[PZ\xFA\x15\x80\x15a\x12%W=__>=_\xFD[PPPPPPV[a\x0C\xD4\x80a\x17}\x839\x01\x90V[a\x0C\xF5\x80a$Q\x839\x01\x90V[a\r\x8C\x80a1F\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x12\xA1W\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\x12mV[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\xC2W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x13\xA8W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x13\x92\x84\x86Qa\x12\xACV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x13XV[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x13\0V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x14 W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x13\xE0V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\xC2W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x14v`@\x88\x01\x82a\x12\xACV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x14\x91\x81\x83a\x13\xCEV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14PV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\xC2W`?\x19\x87\x86\x03\x01\x84Ra\x14\xEA\x85\x83Qa\x12\xACV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\xCEV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\xC2W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x15m`@\x87\x01\x82a\x13\xCEV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15%V[\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\x15\xA6W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x15\xBEW__\xFD[\x845\x93Pa\x15\xCE` \x86\x01a\x15\x83V[\x92Pa\x15\xDC`@\x86\x01a\x15\x83V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x16\0W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x167W\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x16MW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x16\\W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x16sW__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x16\xB7W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\xCDW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x16\xDDW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\xF7Wa\x16\xF7a\x16zV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x17'Wa\x17'a\x16zV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x17>W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x17m`@\x83\x01\x85a\x12\xACV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xA0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x0C\xD48\x03\x80a\x0C\xD4\x839\x81\x01`@\x81\x90Ra\0.\x91a\0?V[`\x01`\x01`\xA0\x1B\x03\x16`\x80Ra\0lV[_` \x82\x84\x03\x12\x15a\0OW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0eW__\xFD[\x93\x92PPPV[`\x80Qa\x0C=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02UW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02y\x91\x90a\x0B,V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xE6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\n\x91\x90a\x0BGV[\x83Q\x90\x91P\x81\x10\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\x9Es\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x85\x83a\x05\xB4V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xB3\x90\x85\x90\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\x90`\x84\x01[`@\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\x0FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05-W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05Q\x91\x90a\x0BGV[a\x05[\x91\x90a\x0B^V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xB3\x90\x85\x90\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\x90`d\x01a\x04OV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x06\n\x90\x84\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\x90`d\x01a\x04OV[PPPV[_a\x06p\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\x07\x1A\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\nW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x8E\x91\x90a\x0B\x9CV[a\x06\nW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[``a\x07(\x84\x84_\x85a\x072V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xC4W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08BW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[__\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\x08j\x91\x90a\x0B\xBBV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xA4W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xA9V[``\x91P[P\x91P\x91Pa\x08\xB9\x82\x82\x86a\x08\xC4V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xD3WP\x81a\x07+V[\x82Q\x15a\x08\xE3W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03t\x91\x90a\x0B\xD1V[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\t8W__\xFD[PV[\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\x8BWa\t\x8Ba\t;V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xBAWa\t\xBAa\t;V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xD5W__\xFD[\x845a\t\xE0\x81a\t\x17V[\x93P` \x85\x015\x92P`@\x85\x015a\t\xF7\x81a\t\x17V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x12W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\"W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nz9,\xA4\xD4K\x0C\x1B\x8D\x91\x90a\x0B\x0BV[\x90Pa\x01L\x85\x85\x85\x84a\x023V[PPPPPV[`@Q\x7Fz~\r\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\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\x7F\0\0\0\0\0\0\0\0\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`$\x83\x01R_\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\x90\x91\x16\x90cz~\r\x92\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\tW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02-\x91\x90a\x0B/V[\x92\x91PPV[a\x02Us\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x043V[a\x02\x96s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\xF7V[`@Q\x7F\xE4hB\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\x83\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\x81\x16`$\x83\x01R\x85\x81\x16`D\x83\x01R`d\x82\x01\x85\x90R_\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\x90\x91\x16\x90c\xE4hB\xB7\x90`\x84\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\\W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x80\x91\x90a\x0B/V[\x82Q\x90\x91P\x81\x10\x15a\x03\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q_\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xF1\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xF2V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05kW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x8F\x91\x90a\x0B/V[a\x05\x99\x91\x90a\x0BFV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xF1\x90\x85\x90\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\x90`d\x01a\x04\x8DV[_a\x06S\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\x07\x02\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\xFDW\x80\x80` \x01\x90Q\x81\x01\x90a\x06q\x91\x90a\x0B~V[a\x06\xFDW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[PPPV[``a\x07\x10\x84\x84_\x85a\x07\x1AV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xACW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08*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\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x03\xEAV[__\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\x08R\x91\x90a\x0B\x9DV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x8CW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x91V[``\x91P[P\x91P\x91Pa\x08\xA1\x82\x82\x86a\x08\xACV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xBBWP\x81a\x07\x13V[\x82Q\x15a\x08\xCBW\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\xEA\x91\x90a\x0B\xB3V[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\t W__\xFD[PV[\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\tsWa\tsa\t#V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xA2Wa\t\xA2a\t#V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xBDW__\xFD[\x845a\t\xC8\x81a\x08\xFFV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xDF\x81a\x08\xFFV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xFAW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\nW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n$Wa\n$a\t#V[a\n7` `\x1F\x19`\x1F\x84\x01\x16\x01a\tyV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nKW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[_` \x82\x84\x03\x12\x15a\n|W__\xFD[\x815a\x07\x13\x81a\x08\xFFV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x9BW__\xFD[\x855a\n\xA6\x81a\x08\xFFV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xBD\x81a\x08\xFFV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xEEW__\xFD[Pa\n\xF7a\tPV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x1CW__\xFD[Pa\x0B%a\tPV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B?W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02-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[_` \x82\x84\x03\x12\x15a\x0B\x8EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x13W__\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\xFE\xA2dipfsX\"\x12 1\xA9_\tS$\x80\xC4eD\\\xF1\xA5F\x84\x08w?\xBD\x88\xEC\xC5\xCAl\x9C\xCA\x82\xDE\xCAb4\x08dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\x8C8\x03\x80a\r\x8C\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\xB6a\0\xD6_9_\x81\x81`\xCB\x01R\x81\x81a\x03\xE1\x01Ra\x04a\x01R_\x81\x81`S\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0C\xB6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c#\x17\x10\xA5\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xA6\xAA\x9C\xC0\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\n=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFB\xFAw\xCF`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B\xA6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x0EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x032\x91\x90a\x0B\xA6V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xC3\x91\x90a\x0B\xC1V[\x90Pa\x04\x06s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x84V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xA2W__\xFD[PZ\xF1\x15\x80\x15a\x04\xB4W=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05~\x90\x85\x90\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\x90`\x84\x01[`@\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\x7FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1C\x91\x90a\x0B\xC1V[a\x06&\x91\x90a\x0B\xD8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05~\x90\x85\x90\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\x90`d\x01a\x05\x1AV[_a\x06\xE0\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\x07\x94\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\x8FW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFE\x91\x90a\x0C\x16V[a\x07\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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x07\xA2\x84\x84_\x85a\x07\xACV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08>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\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\x07\x86V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\xBCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x86V[__\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\x08\xE4\x91\x90a\x0C5V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\t\x1EW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t#V[``\x91P[P\x91P\x91Pa\t3\x82\x82\x86a\t>V[\x97\x96PPPPPPPV[``\x83\x15a\tMWP\x81a\x07\xA5V[\x82Q\x15a\t]W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x86\x91\x90a\x0CKV[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\t\xB2W__\xFD[PV[\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\n\x05Wa\n\x05a\t\xB5V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n4Wa\n4a\t\xB5V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\nOW__\xFD[\x845a\nZ\x81a\t\x91V[\x93P` \x85\x015\x92P`@\x85\x015a\nq\x81a\t\x91V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x8CW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x9CW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xB6Wa\n\xB6a\t\xB5V[a\n\xC9` `\x1F\x19`\x1F\x84\x01\x16\x01a\n\x0BV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n\xDDW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0B\x12W__\xFD[\x855a\x0B\x1D\x81a\t\x91V[\x94P` \x86\x015\x93P`@\x86\x015a\x0B4\x81a\t\x91V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0BeW__\xFD[Pa\x0Bna\t\xE2V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x93W__\xFD[Pa\x0B\x9Ca\t\xE2V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xB6W__\xFD[\x81Qa\x07\xA5\x81a\t\x91V[_` \x82\x84\x03\x12\x15a\x0B\xD1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0C\x10W\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[_` \x82\x84\x03\x12\x15a\x0C&W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\xA5W__\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\xFE\xA2dipfsX\"\x12 #\xC6\x9F\x1F4j\x13~\xBA\xBD\x05\x83\xE0\xB1\x05\x8FN\xC6a;\x1Cg\xB1 >\x01O\x1B\xB3\x9BCgdsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 \x80\xC4k\xF0\xC6\x19\xCE\x07~;\x88Z\xE8M\x89\xB5F\xF0\xE2X\xB6\xE6\xE0\x88\xE6\xEB\xD68b&\x90\x9CdsolcC\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\0\xFBW_5`\xE0\x1C\x80c\x95\x90&i\x11a\0\x93W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x01\xBBW\x80c\xF9\xCE\x0EZ\x14a\x01\xC3W\x80c\xFAv&\xD4\x14a\x01\xD6W\x80c\xFC\x0CTj\x14a\x01\xE3W__\xFD[\x80c\x95\x90&i\x14a\x01\x8BW\x80c\xB0FO\xDC\x14a\x01\x93W\x80c\xB5P\x8A\xA9\x14a\x01\x9BW\x80c\xBAAO\xA6\x14a\x01\xA3W__\xFD[\x80c?r\x86\xF4\x11a\0\xCEW\x80c?r\x86\xF4\x14a\x01DW\x80cf\xD9\xA9\xA0\x14a\x01LW\x80c\x85\"l\x81\x14a\x01aW\x80c\x91j\x17\xC6\x14a\x01vW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x1E\xD7\x83\x1C\x14a\x01\tW\x80c*\xDE8\x80\x14a\x01'W\x80c>^<#\x14a\x01*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x0FTV[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\0W\x83\x82\x90_R` _ \x01\x80Ta\x03u\x90a\x15\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xA1\x90a\x15\xECV[\x80\x15a\x03\xECW\x80`\x1F\x10a\x03\xC3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xECV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xCFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03XV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xFAV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x05I\x90a\x15\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05u\x90a\x15\xECV[\x80\x15a\x05\xC0W\x80`\x1F\x10a\x05\x97Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05\xC0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05\xA3W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06WW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x06\x04W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05\x19V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\x06\xAF\x90a\x15\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06\xDB\x90a\x15\xECV[\x80\x15a\x07&W\x80`\x1F\x10a\x06\xFDWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07&V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\tW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x06\x92V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x08%W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x07\xD2W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07]V[_s*\xC9\x8D\xB4\x1C\xBD1r\xCB{\x8F\xD8\xA8\xAB;\x91\xCF\xE4]\xCF\x90P_\x81`@Qa\x08c\x90a\x12-V[s\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_\xF0\x80\x15\x80\x15a\x08\x99W=__>=_\xFD[P\x90P_r\xB6~H\x05\x13\x83%\xCE\x87\x1D^'\xDC\x15\xF9\x94h\x1B\xC1sc\x1A\xE9~$\xF9\xF3\x01P\xD3\x1D\x95\x8D7\x91Yu\xF1.\xD8`@Qa\x08\xD2\x90a\x12:V[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\t\x0FW=__>=_\xFD[P\x90P_\x82\x82`@Qa\t!\x90a\x12GV[s\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`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\t^W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t\xD8W__\xFD[PZ\xF1\x15\x80\x15a\t\xEAW=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\nmW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\x91\x91\x90a\x16=V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0B%W__\xFD[PZ\xF1\x15\x80\x15a\x0B7W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0B\x94W__\xFD[PZ\xF1\x15\x80\x15a\x0B\xA6W=__>=_\xFD[PP`@Q\x7Ft\xD1E\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\x81R`\x01`\x04\x82\x01Ra\x0CE\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x91Pct\xD1E\xB7\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0C\x17W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0C;\x91\x90a\x16cV[c\x05\xF5\xE1\0a\x11\xAAV[PPPPV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\r6W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C\xE3W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0CnV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x17W\x83\x82\x90_R` _ \x01\x80Ta\r\x8E\x90a\x15\xECV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\xBA\x90a\x15\xECV[\x80\x15a\x0E\x05W\x80`\x1F\x10a\r\xDCWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0E\x05V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r\xE8W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\rqV[`\x08T_\x90`\xFF\x16\x15a\x0E0WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\xBEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\xE2\x91\x90a\x16cV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xCDW` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA2WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F\xEFW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x10\x16\x91\x90\x81\x01\x90a\x16\xA7V[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x104\x92\x91\x90a\x17[V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10PW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10t\x91\x90a\x16cV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10\xEDW__\xFD[PZ\xF1\x15\x80\x15a\x10\xFFW=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x11\x7FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\xA3\x91\x90a\x16=V[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x12\x13W__\xFD[PZ\xFA\x15\x80\x15a\x12%W=__>=_\xFD[PPPPPPV[a\x0C\xD4\x80a\x17}\x839\x01\x90V[a\x0C\xF5\x80a$Q\x839\x01\x90V[a\r\x8C\x80a1F\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x12\xA1W\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\x12mV[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\xC2W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x13\xA8W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x13\x92\x84\x86Qa\x12\xACV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x13XV[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x13\0V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x14 W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x13\xE0V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\xC2W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x14v`@\x88\x01\x82a\x12\xACV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x14\x91\x81\x83a\x13\xCEV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14PV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\xC2W`?\x19\x87\x86\x03\x01\x84Ra\x14\xEA\x85\x83Qa\x12\xACV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\xCEV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\xC2W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x15m`@\x87\x01\x82a\x13\xCEV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x15%V[\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\x15\xA6W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x15\xBEW__\xFD[\x845\x93Pa\x15\xCE` \x86\x01a\x15\x83V[\x92Pa\x15\xDC`@\x86\x01a\x15\x83V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x16\0W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x167W\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x16MW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x16\\W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x16sW__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x16\xB7W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\xCDW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x16\xDDW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\xF7Wa\x16\xF7a\x16zV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x17'Wa\x17'a\x16zV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x17>W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x17m`@\x83\x01\x85a\x12\xACV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xA0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x0C\xD48\x03\x80a\x0C\xD4\x839\x81\x01`@\x81\x90Ra\0.\x91a\0?V[`\x01`\x01`\xA0\x1B\x03\x16`\x80Ra\0lV[_` \x82\x84\x03\x12\x15a\0OW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0eW__\xFD[\x93\x92PPPV[`\x80Qa\x0C=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02UW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02y\x91\x90a\x0B,V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xE6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\n\x91\x90a\x0BGV[\x83Q\x90\x91P\x81\x10\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\x9Es\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x85\x83a\x05\xB4V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xB3\x90\x85\x90\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\x90`\x84\x01[`@\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\x0FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05-W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05Q\x91\x90a\x0BGV[a\x05[\x91\x90a\x0B^V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xB3\x90\x85\x90\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\x90`d\x01a\x04OV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x06\n\x90\x84\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\x90`d\x01a\x04OV[PPPV[_a\x06p\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\x07\x1A\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\nW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x8E\x91\x90a\x0B\x9CV[a\x06\nW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[``a\x07(\x84\x84_\x85a\x072V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xC4W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08BW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[__\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\x08j\x91\x90a\x0B\xBBV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xA4W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xA9V[``\x91P[P\x91P\x91Pa\x08\xB9\x82\x82\x86a\x08\xC4V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xD3WP\x81a\x07+V[\x82Q\x15a\x08\xE3W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03t\x91\x90a\x0B\xD1V[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\t8W__\xFD[PV[\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\x8BWa\t\x8Ba\t;V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xBAWa\t\xBAa\t;V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xD5W__\xFD[\x845a\t\xE0\x81a\t\x17V[\x93P` \x85\x015\x92P`@\x85\x015a\t\xF7\x81a\t\x17V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x12W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\"W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nz9,\xA4\xD4K\x0C\x1B\x8D\x91\x90a\x0B\x0BV[\x90Pa\x01L\x85\x85\x85\x84a\x023V[PPPPPV[`@Q\x7Fz~\r\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\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\x7F\0\0\0\0\0\0\0\0\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`$\x83\x01R_\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\x90\x91\x16\x90cz~\r\x92\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\tW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02-\x91\x90a\x0B/V[\x92\x91PPV[a\x02Us\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x043V[a\x02\x96s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\xF7V[`@Q\x7F\xE4hB\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\x83\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\x81\x16`$\x83\x01R\x85\x81\x16`D\x83\x01R`d\x82\x01\x85\x90R_\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\x90\x91\x16\x90c\xE4hB\xB7\x90`\x84\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\\W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x80\x91\x90a\x0B/V[\x82Q\x90\x91P\x81\x10\x15a\x03\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q_\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xF1\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xF2V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05kW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x8F\x91\x90a\x0B/V[a\x05\x99\x91\x90a\x0BFV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xF1\x90\x85\x90\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\x90`d\x01a\x04\x8DV[_a\x06S\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\x07\x02\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\xFDW\x80\x80` \x01\x90Q\x81\x01\x90a\x06q\x91\x90a\x0B~V[a\x06\xFDW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[PPPV[``a\x07\x10\x84\x84_\x85a\x07\x1AV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xACW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08*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\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x03\xEAV[__\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\x08R\x91\x90a\x0B\x9DV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x8CW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x91V[``\x91P[P\x91P\x91Pa\x08\xA1\x82\x82\x86a\x08\xACV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xBBWP\x81a\x07\x13V[\x82Q\x15a\x08\xCBW\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\xEA\x91\x90a\x0B\xB3V[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\t W__\xFD[PV[\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\tsWa\tsa\t#V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xA2Wa\t\xA2a\t#V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xBDW__\xFD[\x845a\t\xC8\x81a\x08\xFFV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xDF\x81a\x08\xFFV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xFAW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\nW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n$Wa\n$a\t#V[a\n7` `\x1F\x19`\x1F\x84\x01\x16\x01a\tyV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nKW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[_` \x82\x84\x03\x12\x15a\n|W__\xFD[\x815a\x07\x13\x81a\x08\xFFV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x9BW__\xFD[\x855a\n\xA6\x81a\x08\xFFV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xBD\x81a\x08\xFFV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xEEW__\xFD[Pa\n\xF7a\tPV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x1CW__\xFD[Pa\x0B%a\tPV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B?W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02-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[_` \x82\x84\x03\x12\x15a\x0B\x8EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x13W__\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\xFE\xA2dipfsX\"\x12 1\xA9_\tS$\x80\xC4eD\\\xF1\xA5F\x84\x08w?\xBD\x88\xEC\xC5\xCAl\x9C\xCA\x82\xDE\xCAb4\x08dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\x8C8\x03\x80a\r\x8C\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\xB6a\0\xD6_9_\x81\x81`\xCB\x01R\x81\x81a\x03\xE1\x01Ra\x04a\x01R_\x81\x81`S\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0C\xB6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c#\x17\x10\xA5\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xA6\xAA\x9C\xC0\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\n=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFB\xFAw\xCF`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B\xA6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x0EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x032\x91\x90a\x0B\xA6V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xC3\x91\x90a\x0B\xC1V[\x90Pa\x04\x06s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x84V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xA2W__\xFD[PZ\xF1\x15\x80\x15a\x04\xB4W=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05~\x90\x85\x90\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\x90`\x84\x01[`@\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\x7FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1C\x91\x90a\x0B\xC1V[a\x06&\x91\x90a\x0B\xD8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05~\x90\x85\x90\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\x90`d\x01a\x05\x1AV[_a\x06\xE0\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\x07\x94\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\x8FW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFE\x91\x90a\x0C\x16V[a\x07\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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x07\xA2\x84\x84_\x85a\x07\xACV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08>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\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\x07\x86V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\xBCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x86V[__\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\x08\xE4\x91\x90a\x0C5V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\t\x1EW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t#V[``\x91P[P\x91P\x91Pa\t3\x82\x82\x86a\t>V[\x97\x96PPPPPPPV[``\x83\x15a\tMWP\x81a\x07\xA5V[\x82Q\x15a\t]W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x86\x91\x90a\x0CKV[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\t\xB2W__\xFD[PV[\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\n\x05Wa\n\x05a\t\xB5V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n4Wa\n4a\t\xB5V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\nOW__\xFD[\x845a\nZ\x81a\t\x91V[\x93P` \x85\x015\x92P`@\x85\x015a\nq\x81a\t\x91V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x8CW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x9CW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xB6Wa\n\xB6a\t\xB5V[a\n\xC9` `\x1F\x19`\x1F\x84\x01\x16\x01a\n\x0BV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n\xDDW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0B\x12W__\xFD[\x855a\x0B\x1D\x81a\t\x91V[\x94P` \x86\x015\x93P`@\x86\x015a\x0B4\x81a\t\x91V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0BeW__\xFD[Pa\x0Bna\t\xE2V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x93W__\xFD[Pa\x0B\x9Ca\t\xE2V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xB6W__\xFD[\x81Qa\x07\xA5\x81a\t\x91V[_` \x82\x84\x03\x12\x15a\x0B\xD1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0C\x10W\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[_` \x82\x84\x03\x12\x15a\x0C&W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\xA5W__\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\xFE\xA2dipfsX\"\x12 #\xC6\x9F\x1F4j\x13~\xBA\xBD\x05\x83\xE0\xB1\x05\x8FN\xC6a;\x1Cg\xB1 >\x01O\x1B\xB3\x9BCgdsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 \x80\xC4k\xF0\xC6\x19\xCE\x07~;\x88Z\xE8M\x89\xB5F\xF0\xE2X\xB6\xE6\xE0\x88\xE6\xEB\xD68b&\x90\x9CdsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. -```solidity -event log(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `setUp()` and selector `0x0a9254e4`. -```solidity -function setUp() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setUpCall; - ///Container type for the return parameters of the [`setUp()`](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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl setUpReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for setUpCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = setUpReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "setUp()"; - const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - setUpReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. -```solidity -function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferCall { - #[allow(missing_docs)] - pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub sender: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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::Uint<256>, - ); - #[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::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferCall) -> Self { - (value.forkAtBlock, value.sender, value.receiver, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - forkAtBlock: tuple.0, - sender: tuple.1, - receiver: tuple.2, - amount: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl simulateForkAndTransferReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for simulateForkAndTransferCall { - type Parameters<'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::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = simulateForkAndTransferReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; - const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), - ::tokenize( - &self.sender, - ), - ::tokenize( - &self.receiver, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - simulateForkAndTransferReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testPellBedrockStrategy()` and selector `0x95902669`. -```solidity -function testPellBedrockStrategy() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testPellBedrockStrategyCall; - ///Container type for the return parameters of the [`testPellBedrockStrategy()`](testPellBedrockStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testPellBedrockStrategyReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testPellBedrockStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testPellBedrockStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testPellBedrockStrategyReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testPellBedrockStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testPellBedrockStrategyReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testPellBedrockStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testPellBedrockStrategyReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testPellBedrockStrategy()"; - const SELECTOR: [u8; 4] = [149u8, 144u8, 38u8, 105u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testPellBedrockStrategyReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `token()` and selector `0xfc0c546a`. -```solidity -function token() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`token()`](tokenCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for tokenCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "token()"; - const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`PellBedRockStrategyForked`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum PellBedRockStrategyForkedCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - setUp(setUpCall), - #[allow(missing_docs)] - simulateForkAndTransfer(simulateForkAndTransferCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - testPellBedrockStrategy(testPellBedrockStrategyCall), - #[allow(missing_docs)] - token(tokenCall), - } - #[automatically_derived] - impl PellBedRockStrategyForkedCalls { - /// 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]] = &[ - [10u8, 146u8, 84u8, 228u8], - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [102u8, 217u8, 169u8, 160u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [149u8, 144u8, 38u8, 105u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [226u8, 12u8, 159u8, 113u8], - [249u8, 206u8, 14u8, 90u8], - [250u8, 118u8, 38u8, 212u8], - [252u8, 12u8, 84u8, 106u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for PellBedRockStrategyForkedCalls { - const NAME: &'static str = "PellBedRockStrategyForkedCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 16usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::setUp(_) => ::SELECTOR, - Self::simulateForkAndTransfer(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::testPellBedrockStrategy(_) => { - ::SELECTOR - } - Self::token(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(PellBedRockStrategyForkedCalls::setUp) - } - setUp - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedRockStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedRockStrategyForkedCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedRockStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedRockStrategyForkedCalls::targetContracts) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedRockStrategyForkedCalls::targetArtifactSelectors) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedRockStrategyForkedCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedRockStrategyForkedCalls::targetSelectors) - } - targetSelectors - }, - { - fn testPellBedrockStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedRockStrategyForkedCalls::testPellBedrockStrategy) - } - testPellBedrockStrategy - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedRockStrategyForkedCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedRockStrategyForkedCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(PellBedRockStrategyForkedCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedRockStrategyForkedCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedRockStrategyForkedCalls::simulateForkAndTransfer) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(PellBedRockStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(PellBedRockStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockStrategyForkedCalls::setUp) - } - setUp - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockStrategyForkedCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockStrategyForkedCalls::targetContracts) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockStrategyForkedCalls::targetArtifactSelectors) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockStrategyForkedCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockStrategyForkedCalls::targetSelectors) - } - targetSelectors - }, - { - fn testPellBedrockStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockStrategyForkedCalls::testPellBedrockStrategy) - } - testPellBedrockStrategy - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockStrategyForkedCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockStrategyForkedCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockStrategyForkedCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockStrategyForkedCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockStrategyForkedCalls::simulateForkAndTransfer) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedRockStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::setUp(inner) => { - ::abi_encoded_size(inner) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testPellBedrockStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::token(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::setUp(inner) => { - ::abi_encode_raw(inner, out) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testPellBedrockStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::token(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - ///Container for all the [`PellBedRockStrategyForked`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum PellBedRockStrategyForkedEvents { - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl PellBedRockStrategyForkedEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for PellBedRockStrategyForkedEvents { - const NAME: &'static str = "PellBedRockStrategyForkedEvents"; - const COUNT: usize = 22usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 PellBedRockStrategyForkedEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`PellBedRockStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`PellBedRockStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> PellBedRockStrategyForkedInstance { - PellBedRockStrategyForkedInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - PellBedRockStrategyForkedInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - PellBedRockStrategyForkedInstance::::deploy_builder(provider) - } - /**A [`PellBedRockStrategyForked`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`PellBedRockStrategyForked`](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 PellBedRockStrategyForkedInstance< - P, - N = alloy_contract::private::Ethereum, - > { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for PellBedRockStrategyForkedInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("PellBedRockStrategyForkedInstance") - .field(&self.address) - .finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PellBedRockStrategyForkedInstance { - /**Creates a new wrapper around an on-chain [`PellBedRockStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`PellBedRockStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 PellBedRockStrategyForkedInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> PellBedRockStrategyForkedInstance { - PellBedRockStrategyForkedInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PellBedRockStrategyForkedInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`setUp`] function. - pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { - self.call_builder(&setUpCall) - } - ///Creates a new call builder for the [`simulateForkAndTransfer`] function. - pub fn simulateForkAndTransfer( - &self, - forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - sender: alloy::sol_types::private::Address, - receiver: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { - self.call_builder( - &simulateForkAndTransferCall { - forkAtBlock, - sender, - receiver, - amount, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`testPellBedrockStrategy`] function. - pub fn testPellBedrockStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testPellBedrockStrategyCall, N> { - self.call_builder(&testPellBedrockStrategyCall) - } - ///Creates a new call builder for the [`token`] function. - pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { - self.call_builder(&tokenCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PellBedRockStrategyForkedInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/pell_bedrock_strategy.rs b/crates/bindings/src/pell_bedrock_strategy.rs deleted file mode 100644 index a8f23b247..000000000 --- a/crates/bindings/src/pell_bedrock_strategy.rs +++ /dev/null @@ -1,1808 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface PellBedrockStrategy { - struct StrategySlippageArgs { - uint256 amountOutMin; - } - - event TokenOutput(address tokenReceived, uint256 amountOut); - - constructor(address _bedrockStrategy, address _pellStrategy); - - function bedrockStrategy() external view returns (address); - function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; - function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amount, address recipient, StrategySlippageArgs memory args) external; - function pellStrategy() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "_bedrockStrategy", - "type": "address", - "internalType": "contract BedrockStrategy" - }, - { - "name": "_pellStrategy", - "type": "address", - "internalType": "contract PellStrategy" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "bedrockStrategy", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract BedrockStrategy" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "handleGatewayMessage", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "message", - "type": "bytes", - "internalType": "bytes" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessageWithSlippageArgs", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "args", - "type": "tuple", - "internalType": "struct StrategySlippageArgs", - "components": [ - { - "name": "amountOutMin", - "type": "uint256", - "internalType": "uint256" - } - ] - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "pellStrategy", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract PellStrategy" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "TokenOutput", - "inputs": [ - { - "name": "tokenReceived", - "type": "address", - "indexed": false, - "internalType": "address" - }, - { - "name": "amountOut", - "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 PellBedrockStrategy { - use super::*; - use alloy::sol_types as 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\r\x8C8\x03\x80a\r\x8C\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\xB6a\0\xD6_9_\x81\x81`\xCB\x01R\x81\x81a\x03\xE1\x01Ra\x04a\x01R_\x81\x81`S\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0C\xB6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c#\x17\x10\xA5\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xA6\xAA\x9C\xC0\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\n=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFB\xFAw\xCF`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B\xA6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x0EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x032\x91\x90a\x0B\xA6V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xC3\x91\x90a\x0B\xC1V[\x90Pa\x04\x06s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x84V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xA2W__\xFD[PZ\xF1\x15\x80\x15a\x04\xB4W=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05~\x90\x85\x90\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\x90`\x84\x01[`@\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\x7FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1C\x91\x90a\x0B\xC1V[a\x06&\x91\x90a\x0B\xD8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05~\x90\x85\x90\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\x90`d\x01a\x05\x1AV[_a\x06\xE0\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\x07\x94\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\x8FW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFE\x91\x90a\x0C\x16V[a\x07\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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x07\xA2\x84\x84_\x85a\x07\xACV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08>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\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\x07\x86V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\xBCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x86V[__\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\x08\xE4\x91\x90a\x0C5V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\t\x1EW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t#V[``\x91P[P\x91P\x91Pa\t3\x82\x82\x86a\t>V[\x97\x96PPPPPPPV[``\x83\x15a\tMWP\x81a\x07\xA5V[\x82Q\x15a\t]W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x86\x91\x90a\x0CKV[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\t\xB2W__\xFD[PV[\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\n\x05Wa\n\x05a\t\xB5V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n4Wa\n4a\t\xB5V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\nOW__\xFD[\x845a\nZ\x81a\t\x91V[\x93P` \x85\x015\x92P`@\x85\x015a\nq\x81a\t\x91V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x8CW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x9CW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xB6Wa\n\xB6a\t\xB5V[a\n\xC9` `\x1F\x19`\x1F\x84\x01\x16\x01a\n\x0BV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n\xDDW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0B\x12W__\xFD[\x855a\x0B\x1D\x81a\t\x91V[\x94P` \x86\x015\x93P`@\x86\x015a\x0B4\x81a\t\x91V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0BeW__\xFD[Pa\x0Bna\t\xE2V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x93W__\xFD[Pa\x0B\x9Ca\t\xE2V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xB6W__\xFD[\x81Qa\x07\xA5\x81a\t\x91V[_` \x82\x84\x03\x12\x15a\x0B\xD1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0C\x10W\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[_` \x82\x84\x03\x12\x15a\x0C&W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\xA5W__\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\xFE\xA2dipfsX\"\x12 #\xC6\x9F\x1F4j\x13~\xBA\xBD\x05\x83\xE0\xB1\x05\x8FN\xC6a;\x1Cg\xB1 >\x01O\x1B\xB3\x9BCgdsolcC\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#\x17\x10\xA5\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xA6\xAA\x9C\xC0\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\n=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFB\xFAw\xCF`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B\xA6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x0EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x032\x91\x90a\x0B\xA6V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xC3\x91\x90a\x0B\xC1V[\x90Pa\x04\x06s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x84V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xA2W__\xFD[PZ\xF1\x15\x80\x15a\x04\xB4W=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05~\x90\x85\x90\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\x90`\x84\x01[`@\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\x7FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1C\x91\x90a\x0B\xC1V[a\x06&\x91\x90a\x0B\xD8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05~\x90\x85\x90\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\x90`d\x01a\x05\x1AV[_a\x06\xE0\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\x07\x94\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\x8FW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFE\x91\x90a\x0C\x16V[a\x07\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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x07\xA2\x84\x84_\x85a\x07\xACV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08>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\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\x07\x86V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\xBCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x86V[__\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\x08\xE4\x91\x90a\x0C5V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\t\x1EW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t#V[``\x91P[P\x91P\x91Pa\t3\x82\x82\x86a\t>V[\x97\x96PPPPPPPV[``\x83\x15a\tMWP\x81a\x07\xA5V[\x82Q\x15a\t]W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x86\x91\x90a\x0CKV[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\t\xB2W__\xFD[PV[\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\n\x05Wa\n\x05a\t\xB5V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n4Wa\n4a\t\xB5V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\nOW__\xFD[\x845a\nZ\x81a\t\x91V[\x93P` \x85\x015\x92P`@\x85\x015a\nq\x81a\t\x91V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x8CW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x9CW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xB6Wa\n\xB6a\t\xB5V[a\n\xC9` `\x1F\x19`\x1F\x84\x01\x16\x01a\n\x0BV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n\xDDW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0B\x12W__\xFD[\x855a\x0B\x1D\x81a\t\x91V[\x94P` \x86\x015\x93P`@\x86\x015a\x0B4\x81a\t\x91V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0BeW__\xFD[Pa\x0Bna\t\xE2V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x93W__\xFD[Pa\x0B\x9Ca\t\xE2V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xB6W__\xFD[\x81Qa\x07\xA5\x81a\t\x91V[_` \x82\x84\x03\x12\x15a\x0B\xD1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0C\x10W\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[_` \x82\x84\x03\x12\x15a\x0C&W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\xA5W__\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\xFE\xA2dipfsX\"\x12 #\xC6\x9F\x1F4j\x13~\xBA\xBD\x05\x83\xE0\xB1\x05\x8FN\xC6a;\x1Cg\xB1 >\x01O\x1B\xB3\x9BCgdsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct StrategySlippageArgs { uint256 amountOutMin; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct StrategySlippageArgs { - #[allow(missing_docs)] - pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: StrategySlippageArgs) -> Self { - (value.amountOutMin,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for StrategySlippageArgs { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { amountOutMin: tuple.0 } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for StrategySlippageArgs { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for StrategySlippageArgs { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for StrategySlippageArgs { - const NAME: &'static str = "StrategySlippageArgs"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "StrategySlippageArgs(uint256 amountOutMin)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) - .0 - .to_vec() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for StrategySlippageArgs { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.amountOutMin, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.amountOutMin, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. -```solidity -event TokenOutput(address tokenReceived, uint256 amountOut); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct TokenOutput { - #[allow(missing_docs)] - pub tokenReceived: alloy::sol_types::private::Address, - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for TokenOutput { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - tokenReceived: data.0, - amountOut: data.1, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.tokenReceived, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountOut), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 TokenOutput { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&TokenOutput> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - /**Constructor`. -```solidity -constructor(address _bedrockStrategy, address _pellStrategy); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct constructorCall { - #[allow(missing_docs)] - pub _bedrockStrategy: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub _pellStrategy: alloy::sol_types::private::Address, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value._bedrockStrategy, value._pellStrategy) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - _bedrockStrategy: tuple.0, - _pellStrategy: 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> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._bedrockStrategy, - ), - ::tokenize( - &self._pellStrategy, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `bedrockStrategy()` and selector `0x231710a5`. -```solidity -function bedrockStrategy() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct bedrockStrategyCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`bedrockStrategy()`](bedrockStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct bedrockStrategyReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: bedrockStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for bedrockStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: bedrockStrategyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for bedrockStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for bedrockStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "bedrockStrategy()"; - const SELECTOR: [u8; 4] = [35u8, 23u8, 16u8, 165u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: bedrockStrategyReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: bedrockStrategyReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. -```solidity -function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub message: alloy::sol_types::private::Bytes, - } - ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ); - #[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, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.message) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - message: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageCall { - 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, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; - const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.message, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. -```solidity -function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amount, address recipient, StrategySlippageArgs memory args) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub args: ::RustType, - } - ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::primitives::aliases::U256, - alloy::sol_types::private::Address, - ::RustType, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { - (value.tokenSent, value.amount, value.recipient, value.args) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amount: tuple.1, - recipient: tuple.2, - args: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageWithSlippageArgsReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageWithSlippageArgsReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; - const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.args, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `pellStrategy()` and selector `0xa6aa9cc0`. -```solidity -function pellStrategy() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct pellStrategyCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`pellStrategy()`](pellStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct pellStrategyReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: pellStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for pellStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: pellStrategyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for pellStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for pellStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "pellStrategy()"; - const SELECTOR: [u8; 4] = [166u8, 170u8, 156u8, 192u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: pellStrategyReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: pellStrategyReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`PellBedrockStrategy`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum PellBedrockStrategyCalls { - #[allow(missing_docs)] - bedrockStrategy(bedrockStrategyCall), - #[allow(missing_docs)] - handleGatewayMessage(handleGatewayMessageCall), - #[allow(missing_docs)] - handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), - #[allow(missing_docs)] - pellStrategy(pellStrategyCall), - } - #[automatically_derived] - impl PellBedrockStrategyCalls { - /// 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]] = &[ - [35u8, 23u8, 16u8, 165u8], - [80u8, 99u8, 76u8, 14u8], - [127u8, 129u8, 79u8, 53u8], - [166u8, 170u8, 156u8, 192u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for PellBedrockStrategyCalls { - const NAME: &'static str = "PellBedrockStrategyCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 4usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::bedrockStrategy(_) => { - ::SELECTOR - } - Self::handleGatewayMessage(_) => { - ::SELECTOR - } - Self::handleGatewayMessageWithSlippageArgs(_) => { - ::SELECTOR - } - Self::pellStrategy(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn bedrockStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedrockStrategyCalls::bedrockStrategy) - } - bedrockStrategy - }, - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedrockStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - PellBedrockStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - { - fn pellStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellBedrockStrategyCalls::pellStrategy) - } - pellStrategy - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn bedrockStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedrockStrategyCalls::bedrockStrategy) - } - bedrockStrategy - }, - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedrockStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - PellBedrockStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - { - fn pellStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellBedrockStrategyCalls::pellStrategy) - } - pellStrategy - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::bedrockStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::handleGatewayMessage(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::pellStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::bedrockStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::handleGatewayMessage(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::pellStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`PellBedrockStrategy`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum PellBedrockStrategyEvents { - #[allow(missing_docs)] - TokenOutput(TokenOutput), - } - #[automatically_derived] - impl PellBedrockStrategyEvents { - /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for PellBedrockStrategyEvents { - const NAME: &'static str = "PellBedrockStrategyEvents"; - const COUNT: usize = 1usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::TokenOutput) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 PellBedrockStrategyEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`PellBedrockStrategy`](self) contract instance. - -See the [wrapper's documentation](`PellBedrockStrategyInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> PellBedrockStrategyInstance { - PellBedrockStrategyInstance::::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: alloy_contract::private::Network, - >( - provider: P, - _bedrockStrategy: alloy::sol_types::private::Address, - _pellStrategy: alloy::sol_types::private::Address, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - PellBedrockStrategyInstance::< - P, - N, - >::deploy(provider, _bedrockStrategy, _pellStrategy) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - _bedrockStrategy: alloy::sol_types::private::Address, - _pellStrategy: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - PellBedrockStrategyInstance::< - P, - N, - >::deploy_builder(provider, _bedrockStrategy, _pellStrategy) - } - /**A [`PellBedrockStrategy`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`PellBedrockStrategy`](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 PellBedrockStrategyInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for PellBedrockStrategyInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("PellBedrockStrategyInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PellBedrockStrategyInstance { - /**Creates a new wrapper around an on-chain [`PellBedrockStrategy`](self) contract instance. - -See the [wrapper's documentation](`PellBedrockStrategyInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - _bedrockStrategy: alloy::sol_types::private::Address, - _pellStrategy: alloy::sol_types::private::Address, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder( - provider, - _bedrockStrategy, - _pellStrategy, - ); - 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, - _bedrockStrategy: alloy::sol_types::private::Address, - _pellStrategy: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { - _bedrockStrategy, - _pellStrategy, - }, - )[..], - ] - .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 PellBedrockStrategyInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> PellBedrockStrategyInstance { - PellBedrockStrategyInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PellBedrockStrategyInstance { - /// 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( - &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 [`bedrockStrategy`] function. - pub fn bedrockStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, bedrockStrategyCall, N> { - self.call_builder(&bedrockStrategyCall) - } - ///Creates a new call builder for the [`handleGatewayMessage`] function. - pub fn handleGatewayMessage( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - message: alloy::sol_types::private::Bytes, - ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { - self.call_builder( - &handleGatewayMessageCall { - tokenSent, - amountIn, - recipient, - message, - }, - ) - } - ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. - pub fn handleGatewayMessageWithSlippageArgs( - &self, - tokenSent: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - args: ::RustType, - ) -> alloy_contract::SolCallBuilder< - &P, - handleGatewayMessageWithSlippageArgsCall, - N, - > { - self.call_builder( - &handleGatewayMessageWithSlippageArgsCall { - tokenSent, - amount, - recipient, - args, - }, - ) - } - ///Creates a new call builder for the [`pellStrategy`] function. - pub fn pellStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, pellStrategyCall, N> { - self.call_builder(&pellStrategyCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PellBedrockStrategyInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`TokenOutput`] event. - pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/pell_solv_lst_strategy.rs b/crates/bindings/src/pell_solv_lst_strategy.rs deleted file mode 100644 index ee489b92c..000000000 --- a/crates/bindings/src/pell_solv_lst_strategy.rs +++ /dev/null @@ -1,1808 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface PellSolvLSTStrategy { - struct StrategySlippageArgs { - uint256 amountOutMin; - } - - event TokenOutput(address tokenReceived, uint256 amountOut); - - constructor(address _solvLSTStrategy, address _pellStrategy); - - function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; - function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amount, address recipient, StrategySlippageArgs memory args) external; - function pellStrategy() external view returns (address); - function solvLSTStrategy() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "_solvLSTStrategy", - "type": "address", - "internalType": "contract SolvLSTStrategy" - }, - { - "name": "_pellStrategy", - "type": "address", - "internalType": "contract PellStrategy" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessage", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "message", - "type": "bytes", - "internalType": "bytes" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessageWithSlippageArgs", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "args", - "type": "tuple", - "internalType": "struct StrategySlippageArgs", - "components": [ - { - "name": "amountOutMin", - "type": "uint256", - "internalType": "uint256" - } - ] - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "pellStrategy", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract PellStrategy" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "solvLSTStrategy", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract SolvLSTStrategy" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "TokenOutput", - "inputs": [ - { - "name": "tokenReceived", - "type": "address", - "indexed": false, - "internalType": "address" - }, - { - "name": "amountOut", - "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 PellSolvLSTStrategy { - use super::*; - use alloy::sol_types as 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\r 8\x03\x80a\r \x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CJa\0\xD6_9_\x81\x81`{\x01R\x81\x81a\x03u\x01Ra\x03\xF5\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0CJ_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cPcL\x0E\x14a\0NW\x80c\x7F\x81O5\x14a\0cW\x80c\xA6\xAA\x9C\xC0\x14a\0vW\x80c\xF2#L\xF9\x14a\0\xC6W[__\xFD[a\0aa\0\\6`\x04a\t\xD0V[a\0\xEDV[\0[a\0aa\0q6`\x04a\n\x92V[a\x01\x17V[a\0\x9D\x7F\0\0\0\0\0\0\0\0\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\x9D\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 ;\xBE\xA4\0\nXD\x11.v'\xBB\xE5\xECgi\x01\x98\xF0\xDF\xD9,\xA6^&\r\xB6\x93\x85\x0Bf\xA8dsolcC\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\x80cPcL\x0E\x14a\0NW\x80c\x7F\x81O5\x14a\0cW\x80c\xA6\xAA\x9C\xC0\x14a\0vW\x80c\xF2#L\xF9\x14a\0\xC6W[__\xFD[a\0aa\0\\6`\x04a\t\xD0V[a\0\xEDV[\0[a\0aa\0q6`\x04a\n\x92V[a\x01\x17V[a\0\x9D\x7F\0\0\0\0\0\0\0\0\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\x9D\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 ;\xBE\xA4\0\nXD\x11.v'\xBB\xE5\xECgi\x01\x98\xF0\xDF\xD9,\xA6^&\r\xB6\x93\x85\x0Bf\xA8dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct StrategySlippageArgs { uint256 amountOutMin; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct StrategySlippageArgs { - #[allow(missing_docs)] - pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: StrategySlippageArgs) -> Self { - (value.amountOutMin,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for StrategySlippageArgs { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { amountOutMin: tuple.0 } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for StrategySlippageArgs { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for StrategySlippageArgs { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for StrategySlippageArgs { - const NAME: &'static str = "StrategySlippageArgs"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "StrategySlippageArgs(uint256 amountOutMin)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) - .0 - .to_vec() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for StrategySlippageArgs { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.amountOutMin, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.amountOutMin, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. -```solidity -event TokenOutput(address tokenReceived, uint256 amountOut); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct TokenOutput { - #[allow(missing_docs)] - pub tokenReceived: alloy::sol_types::private::Address, - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for TokenOutput { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - tokenReceived: data.0, - amountOut: data.1, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.tokenReceived, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountOut), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 TokenOutput { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&TokenOutput> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - /**Constructor`. -```solidity -constructor(address _solvLSTStrategy, address _pellStrategy); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct constructorCall { - #[allow(missing_docs)] - pub _solvLSTStrategy: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub _pellStrategy: alloy::sol_types::private::Address, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value._solvLSTStrategy, value._pellStrategy) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - _solvLSTStrategy: tuple.0, - _pellStrategy: 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> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._solvLSTStrategy, - ), - ::tokenize( - &self._pellStrategy, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. -```solidity -function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub message: alloy::sol_types::private::Bytes, - } - ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ); - #[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, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.message) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - message: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageCall { - 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, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; - const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.message, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. -```solidity -function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amount, address recipient, StrategySlippageArgs memory args) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub args: ::RustType, - } - ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::primitives::aliases::U256, - alloy::sol_types::private::Address, - ::RustType, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { - (value.tokenSent, value.amount, value.recipient, value.args) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amount: tuple.1, - recipient: tuple.2, - args: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageWithSlippageArgsReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageWithSlippageArgsReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; - const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.args, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `pellStrategy()` and selector `0xa6aa9cc0`. -```solidity -function pellStrategy() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct pellStrategyCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`pellStrategy()`](pellStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct pellStrategyReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: pellStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for pellStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: pellStrategyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for pellStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for pellStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "pellStrategy()"; - const SELECTOR: [u8; 4] = [166u8, 170u8, 156u8, 192u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: pellStrategyReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: pellStrategyReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `solvLSTStrategy()` and selector `0xf2234cf9`. -```solidity -function solvLSTStrategy() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct solvLSTStrategyCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`solvLSTStrategy()`](solvLSTStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct solvLSTStrategyReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: solvLSTStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for solvLSTStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: solvLSTStrategyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for solvLSTStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for solvLSTStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "solvLSTStrategy()"; - const SELECTOR: [u8; 4] = [242u8, 35u8, 76u8, 249u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: solvLSTStrategyReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: solvLSTStrategyReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`PellSolvLSTStrategy`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum PellSolvLSTStrategyCalls { - #[allow(missing_docs)] - handleGatewayMessage(handleGatewayMessageCall), - #[allow(missing_docs)] - handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), - #[allow(missing_docs)] - pellStrategy(pellStrategyCall), - #[allow(missing_docs)] - solvLSTStrategy(solvLSTStrategyCall), - } - #[automatically_derived] - impl PellSolvLSTStrategyCalls { - /// 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, 99u8, 76u8, 14u8], - [127u8, 129u8, 79u8, 53u8], - [166u8, 170u8, 156u8, 192u8], - [242u8, 35u8, 76u8, 249u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for PellSolvLSTStrategyCalls { - const NAME: &'static str = "PellSolvLSTStrategyCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 4usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::handleGatewayMessage(_) => { - ::SELECTOR - } - Self::handleGatewayMessageWithSlippageArgs(_) => { - ::SELECTOR - } - Self::pellStrategy(_) => { - ::SELECTOR - } - Self::solvLSTStrategy(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellSolvLSTStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - PellSolvLSTStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - { - fn pellStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellSolvLSTStrategyCalls::pellStrategy) - } - pellStrategy - }, - { - fn solvLSTStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellSolvLSTStrategyCalls::solvLSTStrategy) - } - solvLSTStrategy - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellSolvLSTStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - PellSolvLSTStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - { - fn pellStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellSolvLSTStrategyCalls::pellStrategy) - } - pellStrategy - }, - { - fn solvLSTStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellSolvLSTStrategyCalls::solvLSTStrategy) - } - solvLSTStrategy - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::handleGatewayMessage(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::pellStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::solvLSTStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::handleGatewayMessage(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::pellStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::solvLSTStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`PellSolvLSTStrategy`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum PellSolvLSTStrategyEvents { - #[allow(missing_docs)] - TokenOutput(TokenOutput), - } - #[automatically_derived] - impl PellSolvLSTStrategyEvents { - /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for PellSolvLSTStrategyEvents { - const NAME: &'static str = "PellSolvLSTStrategyEvents"; - const COUNT: usize = 1usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::TokenOutput) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 PellSolvLSTStrategyEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`PellSolvLSTStrategy`](self) contract instance. - -See the [wrapper's documentation](`PellSolvLSTStrategyInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> PellSolvLSTStrategyInstance { - PellSolvLSTStrategyInstance::::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: alloy_contract::private::Network, - >( - provider: P, - _solvLSTStrategy: alloy::sol_types::private::Address, - _pellStrategy: alloy::sol_types::private::Address, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - PellSolvLSTStrategyInstance::< - P, - N, - >::deploy(provider, _solvLSTStrategy, _pellStrategy) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - _solvLSTStrategy: alloy::sol_types::private::Address, - _pellStrategy: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - PellSolvLSTStrategyInstance::< - P, - N, - >::deploy_builder(provider, _solvLSTStrategy, _pellStrategy) - } - /**A [`PellSolvLSTStrategy`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`PellSolvLSTStrategy`](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 PellSolvLSTStrategyInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for PellSolvLSTStrategyInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("PellSolvLSTStrategyInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PellSolvLSTStrategyInstance { - /**Creates a new wrapper around an on-chain [`PellSolvLSTStrategy`](self) contract instance. - -See the [wrapper's documentation](`PellSolvLSTStrategyInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - _solvLSTStrategy: alloy::sol_types::private::Address, - _pellStrategy: alloy::sol_types::private::Address, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder( - provider, - _solvLSTStrategy, - _pellStrategy, - ); - 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, - _solvLSTStrategy: alloy::sol_types::private::Address, - _pellStrategy: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { - _solvLSTStrategy, - _pellStrategy, - }, - )[..], - ] - .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 PellSolvLSTStrategyInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> PellSolvLSTStrategyInstance { - PellSolvLSTStrategyInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PellSolvLSTStrategyInstance { - /// 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( - &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 [`handleGatewayMessage`] function. - pub fn handleGatewayMessage( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - message: alloy::sol_types::private::Bytes, - ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { - self.call_builder( - &handleGatewayMessageCall { - tokenSent, - amountIn, - recipient, - message, - }, - ) - } - ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. - pub fn handleGatewayMessageWithSlippageArgs( - &self, - tokenSent: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - args: ::RustType, - ) -> alloy_contract::SolCallBuilder< - &P, - handleGatewayMessageWithSlippageArgsCall, - N, - > { - self.call_builder( - &handleGatewayMessageWithSlippageArgsCall { - tokenSent, - amount, - recipient, - args, - }, - ) - } - ///Creates a new call builder for the [`pellStrategy`] function. - pub fn pellStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, pellStrategyCall, N> { - self.call_builder(&pellStrategyCall) - } - ///Creates a new call builder for the [`solvLSTStrategy`] function. - pub fn solvLSTStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, solvLSTStrategyCall, N> { - self.call_builder(&solvLSTStrategyCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PellSolvLSTStrategyInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`TokenOutput`] event. - pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/pell_strategy.rs b/crates/bindings/src/pell_strategy.rs deleted file mode 100644 index 9f5fb32ef..000000000 --- a/crates/bindings/src/pell_strategy.rs +++ /dev/null @@ -1,2032 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface PellStrategy { - struct StrategySlippageArgs { - uint256 amountOutMin; - } - - event TokenOutput(address tokenReceived, uint256 amountOut); - - constructor(address _pellStrategyManager, address _pellStrategy); - - function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; - function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; - function pellStrategy() external view returns (address); - function pellStrategyManager() external view returns (address); - function stakerStrategyShares(address recipient) external view returns (uint256); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "_pellStrategyManager", - "type": "address", - "internalType": "contract IPellStrategyManager" - }, - { - "name": "_pellStrategy", - "type": "address", - "internalType": "contract IPellStrategy" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessage", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "message", - "type": "bytes", - "internalType": "bytes" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessageWithSlippageArgs", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "args", - "type": "tuple", - "internalType": "struct StrategySlippageArgs", - "components": [ - { - "name": "amountOutMin", - "type": "uint256", - "internalType": "uint256" - } - ] - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "pellStrategy", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IPellStrategy" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "pellStrategyManager", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IPellStrategyManager" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "stakerStrategyShares", - "inputs": [ - { - "name": "recipient", - "type": "address", - "internalType": "address" - } - ], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "TokenOutput", - "inputs": [ - { - "name": "tokenReceived", - "type": "address", - "indexed": false, - "internalType": "address" - }, - { - "name": "amountOut", - "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 PellStrategy { - use super::*; - use alloy::sol_types as 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\x0C\xF58\x03\x80a\x0C\xF5\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\x1Ea\0\xD7_9_\x81\x81`\xBB\x01R\x81\x81a\x01\x98\x01Ra\x02\xDB\x01R_\x81\x81a\x01\x07\x01R\x81\x81a\x01\xC2\x01R\x81\x81a\x02q\x01Ra\x03\x14\x01Ra\x0C\x1E_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0dW_5`\xE0\x1C\x80c\x7F\x81O5\x11a\0MW\x80c\x7F\x81O5\x14a\0\xA3W\x80c\xA6\xAA\x9C\xC0\x14a\0\xB6W\x80c\xC9F\x1AD\x14a\x01\x02W__\xFD[\x80cPcL\x0E\x14a\0hW\x80ct\xD1E\xB7\x14a\0}W[__\xFD[a\0{a\0v6`\x04a\t\xAAV[a\x01)V[\0[a\0\x90a\0\x8B6`\x04a\nlV[a\x01SV[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0{a\0\xB16`\x04a\n\x87V[a\x023V[a\0\xDD\x7F\0\0\0\0\0\0\0\0\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\0\x9AV[a\0\xDD\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01>\x91\x90a\x0B\x0BV[\x90Pa\x01L\x85\x85\x85\x84a\x023V[PPPPPV[`@Q\x7Fz~\r\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\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\x7F\0\0\0\0\0\0\0\0\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`$\x83\x01R_\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\x90\x91\x16\x90cz~\r\x92\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\tW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02-\x91\x90a\x0B/V[\x92\x91PPV[a\x02Us\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x043V[a\x02\x96s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\xF7V[`@Q\x7F\xE4hB\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\x83\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\x81\x16`$\x83\x01R\x85\x81\x16`D\x83\x01R`d\x82\x01\x85\x90R_\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\x90\x91\x16\x90c\xE4hB\xB7\x90`\x84\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\\W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x80\x91\x90a\x0B/V[\x82Q\x90\x91P\x81\x10\x15a\x03\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q_\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xF1\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xF2V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05kW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x8F\x91\x90a\x0B/V[a\x05\x99\x91\x90a\x0BFV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xF1\x90\x85\x90\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\x90`d\x01a\x04\x8DV[_a\x06S\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\x07\x02\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\xFDW\x80\x80` \x01\x90Q\x81\x01\x90a\x06q\x91\x90a\x0B~V[a\x06\xFDW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[PPPV[``a\x07\x10\x84\x84_\x85a\x07\x1AV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xACW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08*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\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x03\xEAV[__\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\x08R\x91\x90a\x0B\x9DV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x8CW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x91V[``\x91P[P\x91P\x91Pa\x08\xA1\x82\x82\x86a\x08\xACV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xBBWP\x81a\x07\x13V[\x82Q\x15a\x08\xCBW\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\xEA\x91\x90a\x0B\xB3V[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\t W__\xFD[PV[\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\tsWa\tsa\t#V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xA2Wa\t\xA2a\t#V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xBDW__\xFD[\x845a\t\xC8\x81a\x08\xFFV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xDF\x81a\x08\xFFV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xFAW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\nW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n$Wa\n$a\t#V[a\n7` `\x1F\x19`\x1F\x84\x01\x16\x01a\tyV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nKW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[_` \x82\x84\x03\x12\x15a\n|W__\xFD[\x815a\x07\x13\x81a\x08\xFFV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x9BW__\xFD[\x855a\n\xA6\x81a\x08\xFFV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xBD\x81a\x08\xFFV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xEEW__\xFD[Pa\n\xF7a\tPV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x1CW__\xFD[Pa\x0B%a\tPV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B?W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02-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[_` \x82\x84\x03\x12\x15a\x0B\x8EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x13W__\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\xFE\xA2dipfsX\"\x12 1\xA9_\tS$\x80\xC4eD\\\xF1\xA5F\x84\x08w?\xBD\x88\xEC\xC5\xCAl\x9C\xCA\x82\xDE\xCAb4\x08dsolcC\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\0dW_5`\xE0\x1C\x80c\x7F\x81O5\x11a\0MW\x80c\x7F\x81O5\x14a\0\xA3W\x80c\xA6\xAA\x9C\xC0\x14a\0\xB6W\x80c\xC9F\x1AD\x14a\x01\x02W__\xFD[\x80cPcL\x0E\x14a\0hW\x80ct\xD1E\xB7\x14a\0}W[__\xFD[a\0{a\0v6`\x04a\t\xAAV[a\x01)V[\0[a\0\x90a\0\x8B6`\x04a\nlV[a\x01SV[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0{a\0\xB16`\x04a\n\x87V[a\x023V[a\0\xDD\x7F\0\0\0\0\0\0\0\0\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\0\x9AV[a\0\xDD\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01>\x91\x90a\x0B\x0BV[\x90Pa\x01L\x85\x85\x85\x84a\x023V[PPPPPV[`@Q\x7Fz~\r\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\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\x7F\0\0\0\0\0\0\0\0\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`$\x83\x01R_\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\x90\x91\x16\x90cz~\r\x92\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\tW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02-\x91\x90a\x0B/V[\x92\x91PPV[a\x02Us\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x043V[a\x02\x96s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\xF7V[`@Q\x7F\xE4hB\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\x83\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\x81\x16`$\x83\x01R\x85\x81\x16`D\x83\x01R`d\x82\x01\x85\x90R_\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\x90\x91\x16\x90c\xE4hB\xB7\x90`\x84\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\\W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x80\x91\x90a\x0B/V[\x82Q\x90\x91P\x81\x10\x15a\x03\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q_\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xF1\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xF2V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05kW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x8F\x91\x90a\x0B/V[a\x05\x99\x91\x90a\x0BFV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xF1\x90\x85\x90\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\x90`d\x01a\x04\x8DV[_a\x06S\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\x07\x02\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\xFDW\x80\x80` \x01\x90Q\x81\x01\x90a\x06q\x91\x90a\x0B~V[a\x06\xFDW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[PPPV[``a\x07\x10\x84\x84_\x85a\x07\x1AV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xACW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08*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\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x03\xEAV[__\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\x08R\x91\x90a\x0B\x9DV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x8CW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x91V[``\x91P[P\x91P\x91Pa\x08\xA1\x82\x82\x86a\x08\xACV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xBBWP\x81a\x07\x13V[\x82Q\x15a\x08\xCBW\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\xEA\x91\x90a\x0B\xB3V[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\t W__\xFD[PV[\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\tsWa\tsa\t#V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xA2Wa\t\xA2a\t#V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xBDW__\xFD[\x845a\t\xC8\x81a\x08\xFFV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xDF\x81a\x08\xFFV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xFAW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\nW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n$Wa\n$a\t#V[a\n7` `\x1F\x19`\x1F\x84\x01\x16\x01a\tyV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nKW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[_` \x82\x84\x03\x12\x15a\n|W__\xFD[\x815a\x07\x13\x81a\x08\xFFV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x9BW__\xFD[\x855a\n\xA6\x81a\x08\xFFV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xBD\x81a\x08\xFFV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xEEW__\xFD[Pa\n\xF7a\tPV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x1CW__\xFD[Pa\x0B%a\tPV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B?W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02-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[_` \x82\x84\x03\x12\x15a\x0B\x8EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x13W__\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\xFE\xA2dipfsX\"\x12 1\xA9_\tS$\x80\xC4eD\\\xF1\xA5F\x84\x08w?\xBD\x88\xEC\xC5\xCAl\x9C\xCA\x82\xDE\xCAb4\x08dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct StrategySlippageArgs { uint256 amountOutMin; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct StrategySlippageArgs { - #[allow(missing_docs)] - pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: StrategySlippageArgs) -> Self { - (value.amountOutMin,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for StrategySlippageArgs { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { amountOutMin: tuple.0 } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for StrategySlippageArgs { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for StrategySlippageArgs { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for StrategySlippageArgs { - const NAME: &'static str = "StrategySlippageArgs"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "StrategySlippageArgs(uint256 amountOutMin)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) - .0 - .to_vec() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for StrategySlippageArgs { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.amountOutMin, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.amountOutMin, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. -```solidity -event TokenOutput(address tokenReceived, uint256 amountOut); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct TokenOutput { - #[allow(missing_docs)] - pub tokenReceived: alloy::sol_types::private::Address, - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for TokenOutput { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - tokenReceived: data.0, - amountOut: data.1, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.tokenReceived, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountOut), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 TokenOutput { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&TokenOutput> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - /**Constructor`. -```solidity -constructor(address _pellStrategyManager, address _pellStrategy); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct constructorCall { - #[allow(missing_docs)] - pub _pellStrategyManager: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub _pellStrategy: alloy::sol_types::private::Address, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value._pellStrategyManager, value._pellStrategy) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - _pellStrategyManager: tuple.0, - _pellStrategy: 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> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._pellStrategyManager, - ), - ::tokenize( - &self._pellStrategy, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. -```solidity -function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub message: alloy::sol_types::private::Bytes, - } - ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ); - #[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, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.message) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - message: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageCall { - 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, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; - const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.message, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. -```solidity -function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub args: ::RustType, - } - ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::primitives::aliases::U256, - alloy::sol_types::private::Address, - ::RustType, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.args) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - args: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageWithSlippageArgsReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageWithSlippageArgsReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; - const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.args, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `pellStrategy()` and selector `0xa6aa9cc0`. -```solidity -function pellStrategy() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct pellStrategyCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`pellStrategy()`](pellStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct pellStrategyReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: pellStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for pellStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: pellStrategyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for pellStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for pellStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "pellStrategy()"; - const SELECTOR: [u8; 4] = [166u8, 170u8, 156u8, 192u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: pellStrategyReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: pellStrategyReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `pellStrategyManager()` and selector `0xc9461a44`. -```solidity -function pellStrategyManager() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct pellStrategyManagerCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`pellStrategyManager()`](pellStrategyManagerCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct pellStrategyManagerReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: pellStrategyManagerCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for pellStrategyManagerCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: pellStrategyManagerReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for pellStrategyManagerReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for pellStrategyManagerCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "pellStrategyManager()"; - const SELECTOR: [u8; 4] = [201u8, 70u8, 26u8, 68u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: pellStrategyManagerReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: pellStrategyManagerReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `stakerStrategyShares(address)` and selector `0x74d145b7`. -```solidity -function stakerStrategyShares(address recipient) external view returns (uint256); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct stakerStrategySharesCall { - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`stakerStrategyShares(address)`](stakerStrategySharesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct stakerStrategySharesReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: stakerStrategySharesCall) -> Self { - (value.recipient,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for stakerStrategySharesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { recipient: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: stakerStrategySharesReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for stakerStrategySharesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for stakerStrategySharesCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "stakerStrategyShares(address)"; - const SELECTOR: [u8; 4] = [116u8, 209u8, 69u8, 183u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.recipient, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: stakerStrategySharesReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: stakerStrategySharesReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`PellStrategy`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum PellStrategyCalls { - #[allow(missing_docs)] - handleGatewayMessage(handleGatewayMessageCall), - #[allow(missing_docs)] - handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), - #[allow(missing_docs)] - pellStrategy(pellStrategyCall), - #[allow(missing_docs)] - pellStrategyManager(pellStrategyManagerCall), - #[allow(missing_docs)] - stakerStrategyShares(stakerStrategySharesCall), - } - #[automatically_derived] - impl PellStrategyCalls { - /// 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, 99u8, 76u8, 14u8], - [116u8, 209u8, 69u8, 183u8], - [127u8, 129u8, 79u8, 53u8], - [166u8, 170u8, 156u8, 192u8], - [201u8, 70u8, 26u8, 68u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for PellStrategyCalls { - const NAME: &'static str = "PellStrategyCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 5usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::handleGatewayMessage(_) => { - ::SELECTOR - } - Self::handleGatewayMessageWithSlippageArgs(_) => { - ::SELECTOR - } - Self::pellStrategy(_) => { - ::SELECTOR - } - Self::pellStrategyManager(_) => { - ::SELECTOR - } - Self::stakerStrategyShares(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn stakerStrategyShares( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellStrategyCalls::stakerStrategyShares) - } - stakerStrategyShares - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellStrategyCalls::handleGatewayMessageWithSlippageArgs) - } - handleGatewayMessageWithSlippageArgs - }, - { - fn pellStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellStrategyCalls::pellStrategy) - } - pellStrategy - }, - { - fn pellStrategyManager( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellStrategyCalls::pellStrategyManager) - } - pellStrategyManager - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn stakerStrategyShares( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellStrategyCalls::stakerStrategyShares) - } - stakerStrategyShares - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellStrategyCalls::handleGatewayMessageWithSlippageArgs) - } - handleGatewayMessageWithSlippageArgs - }, - { - fn pellStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellStrategyCalls::pellStrategy) - } - pellStrategy - }, - { - fn pellStrategyManager( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellStrategyCalls::pellStrategyManager) - } - pellStrategyManager - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::handleGatewayMessage(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::pellStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::pellStrategyManager(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::stakerStrategyShares(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::handleGatewayMessage(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::pellStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::pellStrategyManager(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::stakerStrategyShares(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`PellStrategy`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum PellStrategyEvents { - #[allow(missing_docs)] - TokenOutput(TokenOutput), - } - #[automatically_derived] - impl PellStrategyEvents { - /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for PellStrategyEvents { - const NAME: &'static str = "PellStrategyEvents"; - const COUNT: usize = 1usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::TokenOutput) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 PellStrategyEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`PellStrategy`](self) contract instance. - -See the [wrapper's documentation](`PellStrategyInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> PellStrategyInstance { - PellStrategyInstance::::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: alloy_contract::private::Network, - >( - provider: P, - _pellStrategyManager: alloy::sol_types::private::Address, - _pellStrategy: alloy::sol_types::private::Address, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - PellStrategyInstance::< - P, - N, - >::deploy(provider, _pellStrategyManager, _pellStrategy) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - _pellStrategyManager: alloy::sol_types::private::Address, - _pellStrategy: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - PellStrategyInstance::< - P, - N, - >::deploy_builder(provider, _pellStrategyManager, _pellStrategy) - } - /**A [`PellStrategy`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`PellStrategy`](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 PellStrategyInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for PellStrategyInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("PellStrategyInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PellStrategyInstance { - /**Creates a new wrapper around an on-chain [`PellStrategy`](self) contract instance. - -See the [wrapper's documentation](`PellStrategyInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - _pellStrategyManager: alloy::sol_types::private::Address, - _pellStrategy: alloy::sol_types::private::Address, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder( - provider, - _pellStrategyManager, - _pellStrategy, - ); - 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, - _pellStrategyManager: alloy::sol_types::private::Address, - _pellStrategy: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { - _pellStrategyManager, - _pellStrategy, - }, - )[..], - ] - .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 PellStrategyInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> PellStrategyInstance { - PellStrategyInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PellStrategyInstance { - /// 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( - &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 [`handleGatewayMessage`] function. - pub fn handleGatewayMessage( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - message: alloy::sol_types::private::Bytes, - ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { - self.call_builder( - &handleGatewayMessageCall { - tokenSent, - amountIn, - recipient, - message, - }, - ) - } - ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. - pub fn handleGatewayMessageWithSlippageArgs( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - args: ::RustType, - ) -> alloy_contract::SolCallBuilder< - &P, - handleGatewayMessageWithSlippageArgsCall, - N, - > { - self.call_builder( - &handleGatewayMessageWithSlippageArgsCall { - tokenSent, - amountIn, - recipient, - args, - }, - ) - } - ///Creates a new call builder for the [`pellStrategy`] function. - pub fn pellStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, pellStrategyCall, N> { - self.call_builder(&pellStrategyCall) - } - ///Creates a new call builder for the [`pellStrategyManager`] function. - pub fn pellStrategyManager( - &self, - ) -> alloy_contract::SolCallBuilder<&P, pellStrategyManagerCall, N> { - self.call_builder(&pellStrategyManagerCall) - } - ///Creates a new call builder for the [`stakerStrategyShares`] function. - pub fn stakerStrategyShares( - &self, - recipient: alloy::sol_types::private::Address, - ) -> alloy_contract::SolCallBuilder<&P, stakerStrategySharesCall, N> { - self.call_builder( - &stakerStrategySharesCall { - recipient, - }, - ) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PellStrategyInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`TokenOutput`] event. - pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/pell_strategy_forked.rs b/crates/bindings/src/pell_strategy_forked.rs deleted file mode 100644 index 9d7df05ac..000000000 --- a/crates/bindings/src/pell_strategy_forked.rs +++ /dev/null @@ -1,7991 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface PellStrategyForked { - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function setUp() external; - function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function testPellStrategy() external; - function token() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "setUp", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "simulateForkAndTransfer", - "inputs": [ - { - "name": "forkAtBlock", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "sender", - "type": "address", - "internalType": "address" - }, - { - "name": "receiver", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testPellStrategy", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "token", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IERC20" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 PellStrategyForked { - use super::*; - use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15`+W__\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16t\xBB\xA2\xEF\x94]R^<#\x14a\x01=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07`W__\xFD[PZ\xF1\x15\x80\x15a\x07rW=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x07\xF9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\x1D\x91\x90a\x15\x82V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\xB5W__\xFD[PZ\xF1\x15\x80\x15a\x08\xC7W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t$W__\xFD[PZ\xF1\x15\x80\x15a\t6W=__>=_\xFD[PP`@Q\x7Ft\xD1E\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\x81R`\x01`\x04\x82\x01Ra\t\xD9\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x91Pct\xD1E\xB7\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\t\xA7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\xCB\x91\x90a\x15\xA8V[g\r\xE0\xB6\xB3\xA7d\0\0a\x11\tV[PV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\n\x1C\x90a\x151V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\nH\x90a\x151V[\x80\x15a\n\x93W\x80`\x1F\x10a\njWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\x93V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\nvW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\t\xFFV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0B\x92W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0B?W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\n\xCAV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\x95W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0CBW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0B\xCDV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\x0C\xED\x90a\x151V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\x19\x90a\x151V[\x80\x15a\rdW\x80`\x1F\x10a\r;Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rdV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\rGW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xD0V[`\x08T_\x90`\xFF\x16\x15a\r\x8FWP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\x1DW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0EA\x91\x90a\x15\xA8V[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0FNW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x0Fu\x91\x90\x81\x01\x90a\x15\xECV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0F\x93\x92\x91\x90a\x16\xA0V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0F\xAFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xD3\x91\x90a\x15\xA8V[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10LW__\xFD[PZ\xF1\x15\x80\x15a\x10^W=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10\xDEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\x02\x91\x90a\x15\x82V[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x11rW__\xFD[PZ\xFA\x15\x80\x15a\x11\x84W=__>=_\xFD[PPPPPPV[a\x0C\xF5\x80a\x16\xC2\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x11\xE6W\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\x11\xB2V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x07W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x12\xEDW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x12\xD7\x84\x86Qa\x11\xF1V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x12\x9DV[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x12EV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x13eW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x13%V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x07W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x13\xBB`@\x88\x01\x82a\x11\xF1V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x13\xD6\x81\x83a\x13\x13V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x13\x95V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x07W`?\x19\x87\x86\x03\x01\x84Ra\x14/\x85\x83Qa\x11\xF1V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\x13V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x07W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x14\xB2`@\x87\x01\x82a\x13\x13V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14jV[\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\xEBW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x15\x03W__\xFD[\x845\x93Pa\x15\x13` \x86\x01a\x14\xC8V[\x92Pa\x15!`@\x86\x01a\x14\xC8V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x15EW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x15|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`\"`\x04R`$_\xFD[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x15\x92W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x15\xA1W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x15\xB8W__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x15\xFCW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\x12W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x16\"W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\x91\x90a\x0B\x0BV[\x90Pa\x01L\x85\x85\x85\x84a\x023V[PPPPPV[`@Q\x7Fz~\r\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\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\x7F\0\0\0\0\0\0\0\0\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`$\x83\x01R_\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\x90\x91\x16\x90cz~\r\x92\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\tW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02-\x91\x90a\x0B/V[\x92\x91PPV[a\x02Us\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x043V[a\x02\x96s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\xF7V[`@Q\x7F\xE4hB\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\x83\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\x81\x16`$\x83\x01R\x85\x81\x16`D\x83\x01R`d\x82\x01\x85\x90R_\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\x90\x91\x16\x90c\xE4hB\xB7\x90`\x84\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\\W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x80\x91\x90a\x0B/V[\x82Q\x90\x91P\x81\x10\x15a\x03\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q_\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xF1\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xF2V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05kW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x8F\x91\x90a\x0B/V[a\x05\x99\x91\x90a\x0BFV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xF1\x90\x85\x90\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\x90`d\x01a\x04\x8DV[_a\x06S\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\x07\x02\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\xFDW\x80\x80` \x01\x90Q\x81\x01\x90a\x06q\x91\x90a\x0B~V[a\x06\xFDW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[PPPV[``a\x07\x10\x84\x84_\x85a\x07\x1AV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xACW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08*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\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x03\xEAV[__\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\x08R\x91\x90a\x0B\x9DV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x8CW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x91V[``\x91P[P\x91P\x91Pa\x08\xA1\x82\x82\x86a\x08\xACV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xBBWP\x81a\x07\x13V[\x82Q\x15a\x08\xCBW\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\xEA\x91\x90a\x0B\xB3V[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\t W__\xFD[PV[\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\tsWa\tsa\t#V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xA2Wa\t\xA2a\t#V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xBDW__\xFD[\x845a\t\xC8\x81a\x08\xFFV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xDF\x81a\x08\xFFV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xFAW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\nW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n$Wa\n$a\t#V[a\n7` `\x1F\x19`\x1F\x84\x01\x16\x01a\tyV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nKW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[_` \x82\x84\x03\x12\x15a\n|W__\xFD[\x815a\x07\x13\x81a\x08\xFFV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x9BW__\xFD[\x855a\n\xA6\x81a\x08\xFFV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xBD\x81a\x08\xFFV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xEEW__\xFD[Pa\n\xF7a\tPV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x1CW__\xFD[Pa\x0B%a\tPV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B?W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02-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[_` \x82\x84\x03\x12\x15a\x0B\x8EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x13W__\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\xFE\xA2dipfsX\"\x12 1\xA9_\tS$\x80\xC4eD\\\xF1\xA5F\x84\x08w?\xBD\x88\xEC\xC5\xCAl\x9C\xCA\x82\xDE\xCAb4\x08dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 jdsU\xB5\xE9\xE4\x99\xC8\x0C^<#\x14a\x01=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07`W__\xFD[PZ\xF1\x15\x80\x15a\x07rW=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x07\xF9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\x1D\x91\x90a\x15\x82V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\xB5W__\xFD[PZ\xF1\x15\x80\x15a\x08\xC7W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t$W__\xFD[PZ\xF1\x15\x80\x15a\t6W=__>=_\xFD[PP`@Q\x7Ft\xD1E\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\x81R`\x01`\x04\x82\x01Ra\t\xD9\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x91Pct\xD1E\xB7\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\t\xA7W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\xCB\x91\x90a\x15\xA8V[g\r\xE0\xB6\xB3\xA7d\0\0a\x11\tV[PV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\n\x1C\x90a\x151V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\nH\x90a\x151V[\x80\x15a\n\x93W\x80`\x1F\x10a\njWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\n\x93V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\nvW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\t\xFFV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0B\x92W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0B?W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\n\xCAV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\x95W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0CBW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0B\xCDV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\x0C\xED\x90a\x151V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\x19\x90a\x151V[\x80\x15a\rdW\x80`\x1F\x10a\r;Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rdV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\rGW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xD0V[`\x08T_\x90`\xFF\x16\x15a\r\x8FWP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\x1DW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0EA\x91\x90a\x15\xA8V[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0FNW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x0Fu\x91\x90\x81\x01\x90a\x15\xECV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0F\x93\x92\x91\x90a\x16\xA0V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0F\xAFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xD3\x91\x90a\x15\xA8V[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10LW__\xFD[PZ\xF1\x15\x80\x15a\x10^W=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10\xDEW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x11\x02\x91\x90a\x15\x82V[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x11rW__\xFD[PZ\xFA\x15\x80\x15a\x11\x84W=__>=_\xFD[PPPPPPV[a\x0C\xF5\x80a\x16\xC2\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x11\xE6W\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\x11\xB2V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x07W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x12\xEDW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x12\xD7\x84\x86Qa\x11\xF1V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x12\x9DV[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x12EV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x13eW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x13%V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x07W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x13\xBB`@\x88\x01\x82a\x11\xF1V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x13\xD6\x81\x83a\x13\x13V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x13\x95V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x07W`?\x19\x87\x86\x03\x01\x84Ra\x14/\x85\x83Qa\x11\xF1V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14\x13V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x13\x07W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x14\xB2`@\x87\x01\x82a\x13\x13V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14jV[\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\xEBW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x15\x03W__\xFD[\x845\x93Pa\x15\x13` \x86\x01a\x14\xC8V[\x92Pa\x15!`@\x86\x01a\x14\xC8V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x15EW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x15|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`\"`\x04R`$_\xFD[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x15\x92W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x15\xA1W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x15\xB8W__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x15\xFCW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\x12W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x16\"W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16\x91\x90a\x0B\x0BV[\x90Pa\x01L\x85\x85\x85\x84a\x023V[PPPPPV[`@Q\x7Fz~\r\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\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\x7F\0\0\0\0\0\0\0\0\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`$\x83\x01R_\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\x90\x91\x16\x90cz~\r\x92\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\tW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02-\x91\x90a\x0B/V[\x92\x91PPV[a\x02Us\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x043V[a\x02\x96s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\xF7V[`@Q\x7F\xE4hB\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\x83\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\x81\x16`$\x83\x01R\x85\x81\x16`D\x83\x01R`d\x82\x01\x85\x90R_\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\x90\x91\x16\x90c\xE4hB\xB7\x90`\x84\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\\W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x80\x91\x90a\x0B/V[\x82Q\x90\x91P\x81\x10\x15a\x03\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@\x80Q_\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xF1\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xF2V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05kW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x8F\x91\x90a\x0B/V[a\x05\x99\x91\x90a\x0BFV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xF1\x90\x85\x90\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\x90`d\x01a\x04\x8DV[_a\x06S\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\x07\x02\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\xFDW\x80\x80` \x01\x90Q\x81\x01\x90a\x06q\x91\x90a\x0B~V[a\x06\xFDW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[PPPV[``a\x07\x10\x84\x84_\x85a\x07\x1AV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xACW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\xEAV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08*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\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x03\xEAV[__\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\x08R\x91\x90a\x0B\x9DV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x8CW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x91V[``\x91P[P\x91P\x91Pa\x08\xA1\x82\x82\x86a\x08\xACV[\x97\x96PPPPPPPV[``\x83\x15a\x08\xBBWP\x81a\x07\x13V[\x82Q\x15a\x08\xCBW\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\xEA\x91\x90a\x0B\xB3V[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\t W__\xFD[PV[\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\tsWa\tsa\t#V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xA2Wa\t\xA2a\t#V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xBDW__\xFD[\x845a\t\xC8\x81a\x08\xFFV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xDF\x81a\x08\xFFV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xFAW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\nW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n$Wa\n$a\t#V[a\n7` `\x1F\x19`\x1F\x84\x01\x16\x01a\tyV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nKW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[_` \x82\x84\x03\x12\x15a\n|W__\xFD[\x815a\x07\x13\x81a\x08\xFFV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x9BW__\xFD[\x855a\n\xA6\x81a\x08\xFFV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xBD\x81a\x08\xFFV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xEEW__\xFD[Pa\n\xF7a\tPV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x1CW__\xFD[Pa\x0B%a\tPV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B?W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x02-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[_` \x82\x84\x03\x12\x15a\x0B\x8EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\x13W__\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\xFE\xA2dipfsX\"\x12 1\xA9_\tS$\x80\xC4eD\\\xF1\xA5F\x84\x08w?\xBD\x88\xEC\xC5\xCAl\x9C\xCA\x82\xDE\xCAb4\x08dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 jdsU\xB5\xE9\xE4\x99\xC8\x0C = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `setUp()` and selector `0x0a9254e4`. -```solidity -function setUp() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setUpCall; - ///Container type for the return parameters of the [`setUp()`](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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl setUpReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for setUpCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = setUpReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "setUp()"; - const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - setUpReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. -```solidity -function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferCall { - #[allow(missing_docs)] - pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub sender: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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::Uint<256>, - ); - #[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::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferCall) -> Self { - (value.forkAtBlock, value.sender, value.receiver, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - forkAtBlock: tuple.0, - sender: tuple.1, - receiver: tuple.2, - amount: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl simulateForkAndTransferReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for simulateForkAndTransferCall { - type Parameters<'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::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = simulateForkAndTransferReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; - const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), - ::tokenize( - &self.sender, - ), - ::tokenize( - &self.receiver, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - simulateForkAndTransferReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testPellStrategy()` and selector `0x75b593aa`. -```solidity -function testPellStrategy() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testPellStrategyCall; - ///Container type for the return parameters of the [`testPellStrategy()`](testPellStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testPellStrategyReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testPellStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testPellStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testPellStrategyReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testPellStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testPellStrategyReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testPellStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testPellStrategyReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testPellStrategy()"; - const SELECTOR: [u8; 4] = [117u8, 181u8, 147u8, 170u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testPellStrategyReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `token()` and selector `0xfc0c546a`. -```solidity -function token() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`token()`](tokenCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for tokenCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "token()"; - const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`PellStrategyForked`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum PellStrategyForkedCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - setUp(setUpCall), - #[allow(missing_docs)] - simulateForkAndTransfer(simulateForkAndTransferCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - testPellStrategy(testPellStrategyCall), - #[allow(missing_docs)] - token(tokenCall), - } - #[automatically_derived] - impl PellStrategyForkedCalls { - /// 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]] = &[ - [10u8, 146u8, 84u8, 228u8], - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [102u8, 217u8, 169u8, 160u8], - [117u8, 181u8, 147u8, 170u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [226u8, 12u8, 159u8, 113u8], - [249u8, 206u8, 14u8, 90u8], - [250u8, 118u8, 38u8, 212u8], - [252u8, 12u8, 84u8, 106u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for PellStrategyForkedCalls { - const NAME: &'static str = "PellStrategyForkedCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 16usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::setUp(_) => ::SELECTOR, - Self::simulateForkAndTransfer(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::testPellStrategy(_) => { - ::SELECTOR - } - Self::token(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(PellStrategyForkedCalls::setUp) - } - setUp - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellStrategyForkedCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellStrategyForkedCalls::targetContracts) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellStrategyForkedCalls::targetArtifactSelectors) - } - targetArtifactSelectors - }, - { - fn testPellStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellStrategyForkedCalls::testPellStrategy) - } - testPellStrategy - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellStrategyForkedCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellStrategyForkedCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellStrategyForkedCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellStrategyForkedCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(PellStrategyForkedCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellStrategyForkedCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(PellStrategyForkedCalls::simulateForkAndTransfer) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(PellStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(PellStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellStrategyForkedCalls::setUp) - } - setUp - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellStrategyForkedCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellStrategyForkedCalls::targetContracts) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellStrategyForkedCalls::targetArtifactSelectors) - } - targetArtifactSelectors - }, - { - fn testPellStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellStrategyForkedCalls::testPellStrategy) - } - testPellStrategy - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellStrategyForkedCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellStrategyForkedCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellStrategyForkedCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellStrategyForkedCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellStrategyForkedCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellStrategyForkedCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellStrategyForkedCalls::simulateForkAndTransfer) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(PellStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::setUp(inner) => { - ::abi_encoded_size(inner) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testPellStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::token(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::setUp(inner) => { - ::abi_encode_raw(inner, out) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testPellStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::token(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - ///Container for all the [`PellStrategyForked`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum PellStrategyForkedEvents { - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl PellStrategyForkedEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for PellStrategyForkedEvents { - const NAME: &'static str = "PellStrategyForkedEvents"; - const COUNT: usize = 22usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 PellStrategyForkedEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`PellStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`PellStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> PellStrategyForkedInstance { - PellStrategyForkedInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - PellStrategyForkedInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - PellStrategyForkedInstance::::deploy_builder(provider) - } - /**A [`PellStrategyForked`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`PellStrategyForked`](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 PellStrategyForkedInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for PellStrategyForkedInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("PellStrategyForkedInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PellStrategyForkedInstance { - /**Creates a new wrapper around an on-chain [`PellStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`PellStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 PellStrategyForkedInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> PellStrategyForkedInstance { - PellStrategyForkedInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PellStrategyForkedInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`setUp`] function. - pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { - self.call_builder(&setUpCall) - } - ///Creates a new call builder for the [`simulateForkAndTransfer`] function. - pub fn simulateForkAndTransfer( - &self, - forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - sender: alloy::sol_types::private::Address, - receiver: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { - self.call_builder( - &simulateForkAndTransferCall { - forkAtBlock, - sender, - receiver, - amount, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`testPellStrategy`] function. - pub fn testPellStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testPellStrategyCall, N> { - self.call_builder(&testPellStrategyCall) - } - ///Creates a new call builder for the [`token`] function. - pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { - self.call_builder(&tokenCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PellStrategyForkedInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/relay_utils.rs b/crates/bindings/src/relay_utils.rs deleted file mode 100644 index 38fa26fe8..000000000 --- a/crates/bindings/src/relay_utils.rs +++ /dev/null @@ -1,218 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface RelayUtils {} -``` - -...which was generated by the following JSON ABI: -```json -[] -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod RelayUtils { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220a931e155e8aef315bb51684c34bf3038ee4dd45e934c7d5e2b881d667c983ebd64736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"`U`2`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`&WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \xA91\xE1U\xE8\xAE\xF3\x15\xBBQhL4\xBF08\xEEM\xD4^\x93L}^+\x88\x1Df|\x98>\xBDdsolcC\0\x08\x1C\x003", - ); - /// The runtime bytecode of the contract, as deployed on the network. - /// - /// ```text - ///0x730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220a931e155e8aef315bb51684c34bf3038ee4dd45e934c7d5e2b881d667c983ebd64736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \xA91\xE1U\xE8\xAE\xF3\x15\xBBQhL4\xBF08\xEEM\xD4^\x93L}^+\x88\x1Df|\x98>\xBDdsolcC\0\x08\x1C\x003", - ); - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`RelayUtils`](self) contract instance. - -See the [wrapper's documentation](`RelayUtilsInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> RelayUtilsInstance { - RelayUtilsInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - RelayUtilsInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - RelayUtilsInstance::::deploy_builder(provider) - } - /**A [`RelayUtils`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`RelayUtils`](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 RelayUtilsInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for RelayUtilsInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("RelayUtilsInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > RelayUtilsInstance { - /**Creates a new wrapper around an on-chain [`RelayUtils`](self) contract instance. - -See the [wrapper's documentation](`RelayUtilsInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 RelayUtilsInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> RelayUtilsInstance { - RelayUtilsInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > RelayUtilsInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > RelayUtilsInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/safe_erc20.rs b/crates/bindings/src/safe_erc20.rs deleted file mode 100644 index b62a37084..000000000 --- a/crates/bindings/src/safe_erc20.rs +++ /dev/null @@ -1,218 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface SafeERC20 {} -``` - -...which was generated by the following JSON ABI: -```json -[] -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod SafeERC20 { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220d0c38f997d08a2de89d8e0d01283ef76295b0a6b3f9c5bb0e964306fb609e80764736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"`U`2`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`&WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \xD0\xC3\x8F\x99}\x08\xA2\xDE\x89\xD8\xE0\xD0\x12\x83\xEFv)[\nk?\x9C[\xB0\xE9d0o\xB6\t\xE8\x07dsolcC\0\x08\x1C\x003", - ); - /// The runtime bytecode of the contract, as deployed on the network. - /// - /// ```text - ///0x730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220d0c38f997d08a2de89d8e0d01283ef76295b0a6b3f9c5bb0e964306fb609e80764736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \xD0\xC3\x8F\x99}\x08\xA2\xDE\x89\xD8\xE0\xD0\x12\x83\xEFv)[\nk?\x9C[\xB0\xE9d0o\xB6\t\xE8\x07dsolcC\0\x08\x1C\x003", - ); - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`SafeERC20`](self) contract instance. - -See the [wrapper's documentation](`SafeERC20Instance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> SafeERC20Instance { - SafeERC20Instance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - SafeERC20Instance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - SafeERC20Instance::::deploy_builder(provider) - } - /**A [`SafeERC20`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`SafeERC20`](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 SafeERC20Instance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for SafeERC20Instance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("SafeERC20Instance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SafeERC20Instance { - /**Creates a new wrapper around an on-chain [`SafeERC20`](self) contract instance. - -See the [wrapper's documentation](`SafeERC20Instance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 SafeERC20Instance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> SafeERC20Instance { - SafeERC20Instance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SafeERC20Instance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SafeERC20Instance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/safe_math.rs b/crates/bindings/src/safe_math.rs deleted file mode 100644 index f4fed5595..000000000 --- a/crates/bindings/src/safe_math.rs +++ /dev/null @@ -1,218 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface SafeMath {} -``` - -...which was generated by the following JSON ABI: -```json -[] -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod SafeMath { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122058f09f5e12a9aa85fd6612b43f5ccd4644b79e031c89718212d843d4ae286e0364736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"`U`2`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`&WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 X\xF0\x9F^\x12\xA9\xAA\x85\xFDf\x12\xB4?\\\xCDFD\xB7\x9E\x03\x1C\x89q\x82\x12\xD8C\xD4\xAE(n\x03dsolcC\0\x08\x1C\x003", - ); - /// The runtime bytecode of the contract, as deployed on the network. - /// - /// ```text - ///0x730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122058f09f5e12a9aa85fd6612b43f5ccd4644b79e031c89718212d843d4ae286e0364736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 X\xF0\x9F^\x12\xA9\xAA\x85\xFDf\x12\xB4?\\\xCDFD\xB7\x9E\x03\x1C\x89q\x82\x12\xD8C\xD4\xAE(n\x03dsolcC\0\x08\x1C\x003", - ); - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`SafeMath`](self) contract instance. - -See the [wrapper's documentation](`SafeMathInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> SafeMathInstance { - SafeMathInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - SafeMathInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - SafeMathInstance::::deploy_builder(provider) - } - /**A [`SafeMath`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`SafeMath`](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 SafeMathInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for SafeMathInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("SafeMathInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SafeMathInstance { - /**Creates a new wrapper around an on-chain [`SafeMath`](self) contract instance. - -See the [wrapper's documentation](`SafeMathInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 SafeMathInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> SafeMathInstance { - SafeMathInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SafeMathInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SafeMathInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/seg_wit_utils.rs b/crates/bindings/src/seg_wit_utils.rs deleted file mode 100644 index cc356c6b8..000000000 --- a/crates/bindings/src/seg_wit_utils.rs +++ /dev/null @@ -1,723 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface SegWitUtils { - function COINBASE_WITNESS_PK_SCRIPT_LENGTH() external view returns (uint256); - function WITNESS_MAGIC_BYTES() external view returns (bytes6); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "COINBASE_WITNESS_PK_SCRIPT_LENGTH", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "uint256", - "internalType": "uint256" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "WITNESS_MAGIC_BYTES", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bytes6", - "internalType": "bytes6" - } - ], - "stateMutability": "view" - } -] -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod SegWitUtils { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x60e6610033600b8282823980515f1a607314602757634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610603c575f3560e01c8063c6cd9637146040578063e0e2748a14605a575b5f5ffd5b6047602681565b6040519081526020015b60405180910390f35b60807f6a24aa21a9ed000000000000000000000000000000000000000000000000000081565b6040517fffffffffffff00000000000000000000000000000000000000000000000000009091168152602001605156fea2646970667358221220bf3526a08adc2baa9cf339210d5dbbca5e3aa2c5555bc6027a5ea95bf97eed5a64736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"`\xE6a\x003`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`'WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R`\x046\x10` = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: COINBASE_WITNESS_PK_SCRIPT_LENGTHCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for COINBASE_WITNESS_PK_SCRIPT_LENGTHCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: COINBASE_WITNESS_PK_SCRIPT_LENGTHReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for COINBASE_WITNESS_PK_SCRIPT_LENGTHReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for COINBASE_WITNESS_PK_SCRIPT_LENGTHCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::primitives::aliases::U256; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "COINBASE_WITNESS_PK_SCRIPT_LENGTH()"; - const SELECTOR: [u8; 4] = [198u8, 205u8, 150u8, 55u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: COINBASE_WITNESS_PK_SCRIPT_LENGTHReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: COINBASE_WITNESS_PK_SCRIPT_LENGTHReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `WITNESS_MAGIC_BYTES()` and selector `0xe0e2748a`. -```solidity -function WITNESS_MAGIC_BYTES() external view returns (bytes6); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct WITNESS_MAGIC_BYTESCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`WITNESS_MAGIC_BYTES()`](WITNESS_MAGIC_BYTESCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct WITNESS_MAGIC_BYTESReturn { - #[allow(missing_docs)] - pub _0: alloy::sol_types::private::FixedBytes<6>, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: WITNESS_MAGIC_BYTESCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for WITNESS_MAGIC_BYTESCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<6>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<6>,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: WITNESS_MAGIC_BYTESReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for WITNESS_MAGIC_BYTESReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for WITNESS_MAGIC_BYTESCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::FixedBytes<6>; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<6>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "WITNESS_MAGIC_BYTES()"; - const SELECTOR: [u8; 4] = [224u8, 226u8, 116u8, 138u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: WITNESS_MAGIC_BYTESReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: WITNESS_MAGIC_BYTESReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`SegWitUtils`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum SegWitUtilsCalls { - #[allow(missing_docs)] - COINBASE_WITNESS_PK_SCRIPT_LENGTH(COINBASE_WITNESS_PK_SCRIPT_LENGTHCall), - #[allow(missing_docs)] - WITNESS_MAGIC_BYTES(WITNESS_MAGIC_BYTESCall), - } - #[automatically_derived] - impl SegWitUtilsCalls { - /// 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]] = &[ - [198u8, 205u8, 150u8, 55u8], - [224u8, 226u8, 116u8, 138u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for SegWitUtilsCalls { - const NAME: &'static str = "SegWitUtilsCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 2usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::COINBASE_WITNESS_PK_SCRIPT_LENGTH(_) => { - ::SELECTOR - } - Self::WITNESS_MAGIC_BYTES(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn COINBASE_WITNESS_PK_SCRIPT_LENGTH( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SegWitUtilsCalls::COINBASE_WITNESS_PK_SCRIPT_LENGTH) - } - COINBASE_WITNESS_PK_SCRIPT_LENGTH - }, - { - fn WITNESS_MAGIC_BYTES( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SegWitUtilsCalls::WITNESS_MAGIC_BYTES) - } - WITNESS_MAGIC_BYTES - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn COINBASE_WITNESS_PK_SCRIPT_LENGTH( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegWitUtilsCalls::COINBASE_WITNESS_PK_SCRIPT_LENGTH) - } - COINBASE_WITNESS_PK_SCRIPT_LENGTH - }, - { - fn WITNESS_MAGIC_BYTES( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegWitUtilsCalls::WITNESS_MAGIC_BYTES) - } - WITNESS_MAGIC_BYTES - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::COINBASE_WITNESS_PK_SCRIPT_LENGTH(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::WITNESS_MAGIC_BYTES(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::COINBASE_WITNESS_PK_SCRIPT_LENGTH(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::WITNESS_MAGIC_BYTES(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`SegWitUtils`](self) contract instance. - -See the [wrapper's documentation](`SegWitUtilsInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> SegWitUtilsInstance { - SegWitUtilsInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - SegWitUtilsInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - SegWitUtilsInstance::::deploy_builder(provider) - } - /**A [`SegWitUtils`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`SegWitUtils`](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 SegWitUtilsInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for SegWitUtilsInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("SegWitUtilsInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SegWitUtilsInstance { - /**Creates a new wrapper around an on-chain [`SegWitUtils`](self) contract instance. - -See the [wrapper's documentation](`SegWitUtilsInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 SegWitUtilsInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> SegWitUtilsInstance { - SegWitUtilsInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SegWitUtilsInstance { - /// 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( - &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 [`COINBASE_WITNESS_PK_SCRIPT_LENGTH`] function. - pub fn COINBASE_WITNESS_PK_SCRIPT_LENGTH( - &self, - ) -> alloy_contract::SolCallBuilder< - &P, - COINBASE_WITNESS_PK_SCRIPT_LENGTHCall, - N, - > { - self.call_builder(&COINBASE_WITNESS_PK_SCRIPT_LENGTHCall) - } - ///Creates a new call builder for the [`WITNESS_MAGIC_BYTES`] function. - pub fn WITNESS_MAGIC_BYTES( - &self, - ) -> alloy_contract::SolCallBuilder<&P, WITNESS_MAGIC_BYTESCall, N> { - self.call_builder(&WITNESS_MAGIC_BYTESCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SegWitUtilsInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/segment_bedrock_and_lst_strategy_forked.rs b/crates/bindings/src/segment_bedrock_and_lst_strategy_forked.rs deleted file mode 100644 index 799733571..000000000 --- a/crates/bindings/src/segment_bedrock_and_lst_strategy_forked.rs +++ /dev/null @@ -1,8308 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface SegmentBedrockAndLstStrategyForked { - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function setUp() external; - function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function testSegmentBedrockStrategy() external; - function testSegmentSolvLstStrategy() external; - function token() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "setUp", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "simulateForkAndTransfer", - "inputs": [ - { - "name": "forkAtBlock", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "sender", - "type": "address", - "internalType": "address" - }, - { - "name": "receiver", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testSegmentBedrockStrategy", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testSegmentSolvLstStrategy", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "token", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IERC20" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 SegmentBedrockAndLstStrategyForked { - use super::*; - use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15`+W__\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16t\x03\xC7\x05K\xCB9\xF7\xB2\xE5\xB2\xC7\xAC\xB3u\x83\xE3-p\xCF\xA3\0\x17\x90Uae\xC1\x80a\0a_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x14W_5`\xE0\x1C\x80c\x85\"l\x81\x11a\0\xADW\x80c\xBAAO\xA6\x11a\0}W\x80c\xF9\xCE\x0EZ\x11a\0cW\x80c\xF9\xCE\x0EZ\x14a\x01\xE4W\x80c\xFAv&\xD4\x14a\x01\xF7W\x80c\xFC\x0CTj\x14a\x02\x04W__\xFD[\x80c\xBAAO\xA6\x14a\x01\xC4W\x80c\xE2\x0C\x9Fq\x14a\x01\xDCW__\xFD[\x80c\x85\"l\x81\x14a\x01\x8AW\x80c\x91j\x17\xC6\x14a\x01\x9FW\x80c\xB0FO\xDC\x14a\x01\xB4W\x80c\xB5P\x8A\xA9\x14a\x01\xBCW__\xFD[\x80c>^<#\x11a\0\xE8W\x80c>^<#\x14a\x01]W\x80c?r\x86\xF4\x14a\x01eW\x80cf\xD9\xA9\xA0\x14a\x01mW\x80ck9d\x13\x14a\x01\x82W__\xFD[\x80b?+\x1D\x14a\x01\x18W\x80c\n\x92T\xE4\x14a\x01\"W\x80c\x1E\xD7\x83\x1C\x14a\x01*W\x80c*\xDE8\x80\x14a\x01HW[__\xFD[a\x01 a\x024V[\0[a\x01 a\t\xF5V[a\x012a\n2V[`@Qa\x01?\x91\x90a\x1C\xE2V[`@Q\x80\x91\x03\x90\xF3[a\x01Pa\n\x92V[`@Qa\x01?\x91\x90a\x1D[V[a\x012a\x0B\xCEV[a\x012a\x0C,V[a\x01ua\x0C\x8AV[`@Qa\x01?\x91\x90a\x1E\x9EV[a\x01 a\x0E\x03V[a\x01\x92a\x14\xE5V[`@Qa\x01?\x91\x90a\x1F\x1CV[a\x01\xA7a\x15\xB0V[`@Qa\x01?\x91\x90a\x1FsV[a\x01\xA7a\x16\xA6V[a\x01\x92a\x17\x9CV[a\x01\xCCa\x18gV[`@Q\x90\x15\x15\x81R` \x01a\x01?V[a\x012a\x197V[a\x01 a\x01\xF26`\x04a \x01V[a\x19\x95V[`\x1FTa\x01\xCC\x90`\xFF\x16\x81V[`\x1FTa\x02\x1C\x90a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01?V[_s*\xC9\x8D\xB4\x1C\xBD1r\xCB{\x8F\xD8\xA8\xAB;\x91\xCF\xE4]\xCF\x90P_\x81`@Qa\x02Z\x90a\x1C\xA1V[`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x02\x83W=__>=_\xFD[P\x90P_sxH\xF0w^\xEB\xAB\xBFU\xCBtI\x0C\xE6\xD3g>hw:\x90P_\x81`@Qa\x02\xAC\x90a\x1C\xAEV[`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x02\xD5W=__>=_\xFD[P\x90P_\x83\x82`@Qa\x02\xE7\x90a\x1C\xBBV[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03\x17W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x03\x91W__\xFD[PZ\xF1\x15\x80\x15a\x03\xA3W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04\x19W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04=\x91\x90a FV[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xC4W__\xFD[PZ\xF1\x15\x80\x15a\x04\xD6W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05&W__\xFD[PZ\xF1\x15\x80\x15a\x058W=__>=_\xFD[PP`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01R_\x92P`\x01`\x01`\xA0\x1B\x03\x86\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x81W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xA5\x91\x90a lV[\x90Pa\x05\xE7\x81_`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01\x7FUser has seTokens\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1B\xD1V[`\x1FT`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01Ra\x06\x96\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90cp\xA0\x821\x90`$\x01[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x066W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06Z\x91\x90a lV[_`@Q\x80`@\x01`@R\x80`\x17\x81R` \x01\x7FUser has no WBTC tokens\0\0\0\0\0\0\0\0\0\x81RPa\x1CMV[_\x86`\x01`\x01`\xA0\x1B\x03\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD3W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF7\x91\x90a \x83V[`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01R\x90\x91Pa\x07\xA1\x90`\x01`\x01`\xA0\x1B\x03\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07AW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07e\x91\x90a lV[_`@Q\x80`@\x01`@R\x80`\x19\x81R` \x01\x7FUser has no uniBTC tokens\0\0\0\0\0\0\0\x81RPa\x1CMV[`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\x04W__\xFD[PZ\xF1\x15\x80\x15a\x08\x16W=__>=_\xFD[PP`@Q\x7F\xDB\0ju\0\0\0\0\0\0\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`\x01`\xA0\x1B\x03\x88\x16\x92Pc\xDB\0ju\x91P`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x08wW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\x9B\x91\x90a lV[P`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x86\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\xDFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\x03\x91\x90a lV[\x91Pa\tE\x82_`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01\x7FUser has redeemed\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1CMV[`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01Ra\t\xEC\x90`\x01`\x01`\xA0\x1B\x03\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\t\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\xB0\x91\x90a lV[_`@Q\x80`@\x01`@R\x80`\x1F\x81R` \x01\x7FUser increase in uniBTC Balance\0\x81RPa\x1B\xD1V[PPPPPPPV[a\n0bi\xFC\x8AsZ\x8E\x97t\xD6\x7F\xE8F\xC6\xF41\x1C\x07>*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x19\x95V[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\n\x88W` \x02\x82\x01\x91\x90_R` _ \x90[\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\njW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x0B\xAEW\x83\x82\x90_R` _ \x01\x80Ta\x0B#\x90a \x9EV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0BO\x90a \x9EV[\x80\x15a\x0B\x9AW\x80`\x1F\x10a\x0BqWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\x9AV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B}W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0B\x06V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\n\xB5V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\n\x88W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\njWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\n\x88W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\njWPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x0C\xDD\x90a \x9EV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\t\x90a \x9EV[\x80\x15a\rTW\x80`\x1F\x10a\r+Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rTV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r7W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\r\xEBW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\x98W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xADV[_sT\x1F\xD7IA\x9C\xA8\x06\xA8\xBC}\xA8\xAC#\xD3F\xF2\xDF\x8Bw\x90P_s\xCC\tf\xD8A\x8DA,Y\x9Ad!\xB7`\xA8G\xEB\x16\x9A\x8C\x90P_sI\xB0r\x15\x85d\xDB60E\x18\xFF\xA3{\x1C\xFC\x13\x91j\x90s\xBAF\xFC\xC1kFM\x97\x871Ag\xBD\xD9\xF1\xCE(@[\xA1\x7FVdR\x02@\xA4kK>\x96U\xC2\x0C\xC3\xF9\xE0\x84\x96\xA9\xB7F\xA4x\xE4v\xAE>\x04\xD6\xC8\xFC1\x7Fh\x99\xA7\xE1;e_\xA3g \x8C\xB2|n\xAA$\x107\r\x15e\xDC\x1F_\x11\x85:\x1E\x8C\xBE\xF03\x86\x86`@Qa\x0E\xAE\x90a\x1C\xC8V[`\x01`\x01`\xA0\x1B\x03\x96\x87\x16\x81R\x94\x86\x16` \x86\x01R`@\x85\x01\x93\x90\x93R``\x84\x01\x91\x90\x91R\x83\x16`\x80\x83\x01R\x90\x91\x16`\xA0\x82\x01R`\xC0\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x0E\xFEW=__>=_\xFD[P\x90P_s^\xF2\xB8\xFB\xCC\x8A\xEA*\x9D\xBE')\xF0\xAC\xF3>\x07?\xA4>\x90P_\x81`@Qa\x0F'\x90a\x1C\xAEV[`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x0FPW=__>=_\xFD[P\x90P_\x83\x82`@Qa\x0Fb\x90a\x1C\xD5V[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x0F\x92W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10\x0CW__\xFD[PZ\xF1\x15\x80\x15a\x10\x1EW=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10\x94W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\xB8\x91\x90a FV[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x11?W__\xFD[PZ\xF1\x15\x80\x15a\x11QW=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x11\xA1W__\xFD[PZ\xF1\x15\x80\x15a\x11\xB3W=__>=_\xFD[PP`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01R_\x92P`\x01`\x01`\xA0\x1B\x03\x86\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\xFCW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12 \x91\x90a lV[\x90Pa\x12b\x81_`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01\x7FUser has seTokens\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1B\xD1V[`\x1FT`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01Ra\x12\x9A\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90cp\xA0\x821\x90`$\x01a\x06\x1BV[`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12\xFDW__\xFD[PZ\xF1\x15\x80\x15a\x13\x0FW=__>=_\xFD[PP`@Q\x7F\xDB\0ju\0\0\0\0\0\0\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`\x01`\x01`\xA0\x1B\x03\x87\x16\x92Pc\xDB\0ju\x91P`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x13pW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13\x94\x91\x90a lV[P`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x85\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x13\xD8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13\xFC\x91\x90a lV[\x90Pa\x14>\x81_`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01\x7FUser has redeemed\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1CMV[`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01Ra\t\xEC\x90`\x01`\x01`\xA0\x1B\x03\x88\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x14\x85W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x14\xA9\x91\x90a lV[_`@Q\x80`@\x01`@R\x80`\x1B\x81R` \x01\x7FUser has SolvBTC.BBN tokens\0\0\0\0\0\x81RPa\x1B\xD1V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W\x83\x82\x90_R` _ \x01\x80Ta\x15%\x90a \x9EV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x15Q\x90a \x9EV[\x80\x15a\x15\x9CW\x80`\x1F\x10a\x15sWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x15\x9CV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15\x7FW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x15\x08V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x16\x8EW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x16;W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x15\xD3V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x17\x84W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x171W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x16\xC9V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W\x83\x82\x90_R` _ \x01\x80Ta\x17\xDC\x90a \x9EV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x18\x08\x90a \x9EV[\x80\x15a\x18SW\x80`\x1F\x10a\x18*Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x18SV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x186W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x17\xBFV[`\x08T_\x90`\xFF\x16\x15a\x18~WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x19\x0CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x190\x91\x90a lV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\n\x88W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\njWPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1A0W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x1AW\x91\x90\x81\x01\x90a!\x1CV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1Au\x92\x91\x90a!\xD0V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x1A\x91W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1A\xB5\x91\x90a lV[P`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1B!W__\xFD[PZ\xF1\x15\x80\x15a\x1B3W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x1B\xA6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1B\xCA\x91\x90a FV[PPPPPV[`@Q\x7F\xD9\xA3\xC4\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xD9\xA3\xC4\xD2\x90a\x1C%\x90\x86\x90\x86\x90\x86\x90`\x04\x01a!\xF1V[_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1C;W__\xFD[PZ\xFA\x15\x80\x15a\t\xECW=__>=_\xFD[`@Q\x7F\x88\xB4L\x85\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x88\xB4L\x85\x90a\x1C%\x90\x86\x90\x86\x90\x86\x90`\x04\x01a!\xF1V[a\x0C\xD4\x80a\"\x19\x839\x01\x90V[a\x0C\xC6\x80a.\xED\x839\x01\x90V[a\r\x8C\x80a;\xB3\x839\x01\x90V[a\x0F-\x80aI?\x839\x01\x90V[a\r \x80aXl\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1D\"W\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1C\xFBV[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1E6W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`\x01`\x01`\xA0\x1B\x03\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x1E\x1CW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x1E\x06\x84\x86Qa\x1D-V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x1D\xCCV[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x1D\x81V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x1E\x94W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x1ETV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1E6W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x1E\xEA`@\x88\x01\x82a\x1D-V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x1F\x05\x81\x83a\x1EBV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1E\xC4V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1E6W`?\x19\x87\x86\x03\x01\x84Ra\x1F^\x85\x83Qa\x1D-V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1FBV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1E6W`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1F\xD4`@\x87\x01\x82a\x1EBV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1F\x99V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x1F\xFEW__\xFD[PV[____`\x80\x85\x87\x03\x12\x15a \x14W__\xFD[\x845\x93P` \x85\x015a &\x81a\x1F\xEAV[\x92P`@\x85\x015a 6\x81a\x1F\xEAV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[_` \x82\x84\x03\x12\x15a VW__\xFD[\x81Q\x80\x15\x15\x81\x14a eW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a |W__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a \x93W__\xFD[\x81Qa e\x81a\x1F\xEAV[`\x01\x81\x81\x1C\x90\x82\x16\x80a \xB2W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a \xE9W\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[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!,W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a!BW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a!RW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a!lWa!la \xEFV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a!\x9CWa!\x9Ca \xEFV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a!\xB3W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a!\xE2`@\x83\x01\x85a\x1D-V[\x90P\x82` \x83\x01R\x93\x92PPPV[\x83\x81R\x82` \x82\x01R```@\x82\x01R_a\"\x0F``\x83\x01\x84a\x1D-V[\x95\x94PPPPPV\xFE`\xA0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x0C\xD48\x03\x80a\x0C\xD4\x839\x81\x01`@\x81\x90Ra\0.\x91a\0?V[`\x01`\x01`\xA0\x1B\x03\x16`\x80Ra\0lV[_` \x82\x84\x03\x12\x15a\0OW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0eW__\xFD[\x93\x92PPPV[`\x80Qa\x0C=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02UW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02y\x91\x90a\x0B,V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xE6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\n\x91\x90a\x0BGV[\x83Q\x90\x91P\x81\x10\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\x9Es\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x85\x83a\x05\xB4V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xB3\x90\x85\x90\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\x90`\x84\x01[`@\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\x0FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05-W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05Q\x91\x90a\x0BGV[a\x05[\x91\x90a\x0B^V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xB3\x90\x85\x90\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\x90`d\x01a\x04OV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x06\n\x90\x84\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\x90`d\x01a\x04OV[PPPV[_a\x06p\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\x07\x1A\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\nW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x8E\x91\x90a\x0B\x9CV[a\x06\nW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[``a\x07(\x84\x84_\x85a\x072V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xC4W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08BW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[__\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\x08j\x91\x90a\x0B\xBBV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xA4W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xA9V[``\x91P[P\x91P\x91Pa\x08\xB9\x82\x82\x86a\x08\xC4V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xD3WP\x81a\x07+V[\x82Q\x15a\x08\xE3W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03t\x91\x90a\x0B\xD1V[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\t8W__\xFD[PV[\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\x8BWa\t\x8Ba\t;V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xBAWa\t\xBAa\t;V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xD5W__\xFD[\x845a\t\xE0\x81a\t\x17V[\x93P` \x85\x015\x92P`@\x85\x015a\t\xF7\x81a\t\x17V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x12W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\"W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nz9,\xA4\xD4K\x0C\x1B\x8D=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xFA\x91\x90a\x0B\x1EV[`@Q\x7F#2>\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x88\x90R\x91\x92P_\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\x90c#2>\x03\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02\x91W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xB5\x91\x90a\x0B\x1EV[\x90P\x80\x15a\x03\nW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FCould not mint token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@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\x86\x81\x16`\x04\x83\x01R_\x91\x90\x85\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03wW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x9B\x91\x90a\x0B\x1EV[\x90P\x82\x81\x11a\x03\xECW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[_a\x03\xF7\x84\x83a\x0BbV[\x86Q\x90\x91P\x81\x10\x15a\x04KW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05c\x90\x85\x90\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\x90`\x84\x01[`@\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\x06dV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xDDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x01\x91\x90a\x0B\x1EV[a\x06\x0B\x91\x90a\x0B{V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05c\x90\x85\x90\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\x90`d\x01a\x04\xFFV[_a\x06\xC5\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\x07Z\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07UW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xE3\x91\x90a\x0B\x8EV[a\x07UW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[PPPV[``a\x07h\x84\x84_\x85a\x07rV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xEAW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08NW`@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\x03\x01V[__\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\x08v\x91\x90a\x0B\xADV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB0W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB5V[``\x91P[P\x91P\x91Pa\x08\xC5\x82\x82\x86a\x08\xD0V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xDFWP\x81a\x07kV[\x82Q\x15a\x08\xEFW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\x01\x91\x90a\x0B\xC3V[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\t*W__\xFD[PV[\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}Wa\t}a\t-V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xACWa\t\xACa\t-V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xC7W__\xFD[\x845a\t\xD2\x81a\t\tV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xE9\x81a\t\tV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x04W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x14W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n.Wa\n.a\t-V[a\nA` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x83V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nUW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x8AW__\xFD[\x855a\n\x95\x81a\t\tV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xAC\x81a\t\tV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xDDW__\xFD[Pa\n\xE6a\tZV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x0BW__\xFD[Pa\x0B\x14a\tZV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B.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`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x0BuWa\x0Bua\x0B5V[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0BuWa\x0Bua\x0B5V[_` \x82\x84\x03\x12\x15a\x0B\x9EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07kW__\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\xFE\xA2dipfsX\"\x12 \x96\xEFe\xB7\x9F\r\x80\x90U\x93\x15 \xD9\x88!\x13\xA9\xD5\xB6{=\xE4\xB8guk\xD84\x96\x11p%dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\x8C8\x03\x80a\r\x8C\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\xB6a\0\xD6_9_\x81\x81`\xCB\x01R\x81\x81a\x03\xE1\x01Ra\x04a\x01R_\x81\x81`S\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0C\xB6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c#\x17\x10\xA5\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xB0\xF1\xE3u\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\n=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFB\xFAw\xCF`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B\xA6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x0EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x032\x91\x90a\x0B\xA6V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xC3\x91\x90a\x0B\xC1V[\x90Pa\x04\x06s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x84V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xA2W__\xFD[PZ\xF1\x15\x80\x15a\x04\xB4W=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05~\x90\x85\x90\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\x90`\x84\x01[`@\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\x7FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1C\x91\x90a\x0B\xC1V[a\x06&\x91\x90a\x0B\xD8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05~\x90\x85\x90\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\x90`d\x01a\x05\x1AV[_a\x06\xE0\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\x07\x94\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\x8FW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFE\x91\x90a\x0C\x16V[a\x07\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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x07\xA2\x84\x84_\x85a\x07\xACV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08>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\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\x07\x86V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\xBCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x86V[__\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\x08\xE4\x91\x90a\x0C5V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\t\x1EW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t#V[``\x91P[P\x91P\x91Pa\t3\x82\x82\x86a\t>V[\x97\x96PPPPPPPV[``\x83\x15a\tMWP\x81a\x07\xA5V[\x82Q\x15a\t]W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x86\x91\x90a\x0CKV[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\t\xB2W__\xFD[PV[\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\n\x05Wa\n\x05a\t\xB5V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n4Wa\n4a\t\xB5V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\nOW__\xFD[\x845a\nZ\x81a\t\x91V[\x93P` \x85\x015\x92P`@\x85\x015a\nq\x81a\t\x91V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x8CW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x9CW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xB6Wa\n\xB6a\t\xB5V[a\n\xC9` `\x1F\x19`\x1F\x84\x01\x16\x01a\n\x0BV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n\xDDW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0B\x12W__\xFD[\x855a\x0B\x1D\x81a\t\x91V[\x94P` \x86\x015\x93P`@\x86\x015a\x0B4\x81a\t\x91V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0BeW__\xFD[Pa\x0Bna\t\xE2V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x93W__\xFD[Pa\x0B\x9Ca\t\xE2V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xB6W__\xFD[\x81Qa\x07\xA5\x81a\t\x91V[_` \x82\x84\x03\x12\x15a\x0B\xD1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0C\x10W\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[_` \x82\x84\x03\x12\x15a\x0C&W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\xA5W__\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\xFE\xA2dipfsX\"\x12 \xC8o\xCDB\x03\x85\xE3\xD8\xE52\x96F\x87\xCC\x1Eo\xE7\xC4i\x88\x13fC'6\x1Dq);\xA3\xF6ydsolcC\0\x08\x1C\x003a\x01@`@R4\x80\x15a\0\x10W__\xFD[P`@Qa\x0F-8\x03\x80a\x0F-\x839\x81\x01`@\x81\x90Ra\0/\x91a\0sV[`\x01`\x01`\xA0\x1B\x03\x95\x86\x16`\x80R\x93\x85\x16`\xA0R`\xC0\x92\x90\x92R`\xE0R\x82\x16a\x01\0R\x16a\x01 Ra\0\xE3V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0pW__\xFD[PV[______`\xC0\x87\x89\x03\x12\x15a\0\x88W__\xFD[\x86Qa\0\x93\x81a\0\\V[` \x88\x01Q\x90\x96Pa\0\xA4\x81a\0\\V[`@\x88\x01Q``\x89\x01Q`\x80\x8A\x01Q\x92\x97P\x90\x95P\x93Pa\0\xC4\x81a\0\\V[`\xA0\x88\x01Q\x90\x92Pa\0\xD5\x81a\0\\V[\x80\x91PP\x92\x95P\x92\x95P\x92\x95V[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\r\xC6a\x01g_9_\x81\x81a\x01.\x01R\x81\x81a\x04\xFC\x01Ra\x05>\x01R_\x81\x81a\x01U\x01Ra\x03R\x01R_\x81\x81a\x01\xB1\x01Ra\x03\xC1\x01R_\x81\x81a\x01|\x01Ra\x02\x88\x01R_\x81\x81`\xDF\x01R\x81\x81a\x03t\x01Ra\x03\xF0\x01R_\x81\x81`\x8E\x01R\x81\x81a\x02;\x01Ra\x02\xB7\x01Ra\r\xC6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\x85W_5`\xE0\x1C\x80c\xADt}\xE6\x11a\0XW\x80c\xADt}\xE6\x14a\x01)W\x80c\xB9\x93|\xCB\x14a\x01PW\x80c\xC8\xC7\xF7\x01\x14a\x01wW\x80c\xE3L\xEF\x86\x14a\x01\xACW__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0\x89W\x80cN=\xF3\xF4\x14a\0\xDAW\x80cPcL\x0E\x14a\x01\x01W\x80c\x7F\x81O5\x14a\x01\x16W[__\xFD[a\0\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\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\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\x81V[a\x01\x14a\x01\x0F6`\x04a\x0BgV[a\x01\xD3V[\0[a\x01\x14a\x01$6`\x04a\x0C)V[a\x01\xFDV[a\0\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\x81V[a\0\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\x81V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xD1V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\xE8\x91\x90a\x0C\xADV[\x90Pa\x01\xF6\x85\x85\x85\x84a\x01\xFDV[PPPPPV[a\x02\x1Fs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x9AV[a\x02`s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x036\x91\x90a\x0C\xD1V[\x90Pa\x03\x99s\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\x7F\0\0\0\0\0\0\0\0\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\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x82\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04KW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04o\x91\x90a\x0C\xD1V[\x83Q\x90\x91P\x81\x10\x15a\x04\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[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\x85\x83a\x07YV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x06X\x90\x85\x90\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\x90`\x84\x01[`@\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\x07\xB4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF6\x91\x90a\x0C\xD1V[a\x07\0\x91\x90a\x0C\xE8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x06X\x90\x85\x90\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\x90`d\x01a\x05\xF4V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07\xAF\x90\x84\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\x90`d\x01a\x05\xF4V[PPPV[_a\x08\x15\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\x08\xBF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\xAFW\x80\x80` \x01\x90Q\x81\x01\x90a\x083\x91\x90a\r&V[a\x07\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\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\x04\xD9V[``a\x08\xCD\x84\x84_\x85a\x08\xD7V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\tiW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x04\xD9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\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`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x04\xD9V[__\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\n\x0F\x91\x90a\rEV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\nIW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\nNV[``\x91P[P\x91P\x91Pa\n^\x82\x82\x86a\niV[\x97\x96PPPPPPPV[``\x83\x15a\nxWP\x81a\x08\xD0V[\x82Q\x15a\n\x88W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x04\xD9\x91\x90a\r[V[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\xDDW__\xFD[PV[\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\x0B0Wa\x0B0a\n\xE0V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0B_Wa\x0B_a\n\xE0V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0BzW__\xFD[\x845a\x0B\x85\x81a\n\xBCV[\x93P` \x85\x015\x92P`@\x85\x015a\x0B\x9C\x81a\n\xBCV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xB7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\x0B\xC7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xE1Wa\x0B\xE1a\n\xE0V[a\x0B\xF4` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0B6V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0C\x08W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0C=W__\xFD[\x855a\x0CH\x81a\n\xBCV[\x94P` \x86\x015\x93P`@\x86\x015a\x0C_\x81a\n\xBCV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0C\x90W__\xFD[Pa\x0C\x99a\x0B\rV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0C\xBEW__\xFD[Pa\x0C\xC7a\x0B\rV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C\xE1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\r 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[_` \x82\x84\x03\x12\x15a\r6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x08\xD0W__\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\xFE\xA2dipfsX\"\x12 \xD28\x8C\xB3\xDCz\xA6\xF5\xA2\xEBuA}\x11\x05\x9B\xE1<\x8C\x9E\xAB\xE5\xD7\xEA\xDB\x1BV\x1F\x93\x7F\xF6\x91dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r 8\x03\x80a\r \x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CJa\0\xD6_9_\x81\x81`{\x01R\x81\x81a\x03u\x01Ra\x03\xF5\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0CJ_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cPcL\x0E\x14a\0NW\x80c\x7F\x81O5\x14a\0cW\x80c\xB0\xF1\xE3u\x14a\0vW\x80c\xF2#L\xF9\x14a\0\xC6W[__\xFD[a\0aa\0\\6`\x04a\t\xD0V[a\0\xEDV[\0[a\0aa\0q6`\x04a\n\x92V[a\x01\x17V[a\0\x9D\x7F\0\0\0\0\0\0\0\0\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\x9D\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 \"\x8F\x03\x84\x07\x19t\xAAf\xF7u\xC6\x06\xB7\xDD\x8B\x8AKq\xA1\x9E<9!\xA2\xDD\xC4}\xE1\xC4\xDAcdsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 Ro.\xA5\xB6\x05\xF8m\x98\x0B\x9Cn\x962\xA2\xC4h\x14\xCB\xAF\x88\xEB\x14})\xE6\xFEc \x1E\xA5\xF9dsolcC\0\x08\x1C\x003", - ); - /// The runtime bytecode of the contract, as deployed on the network. - /// - /// ```text - ///0x608060405234801561000f575f5ffd5b5060043610610114575f3560e01c806385226c81116100ad578063ba414fa61161007d578063f9ce0e5a11610063578063f9ce0e5a146101e4578063fa7626d4146101f7578063fc0c546a14610204575f5ffd5b8063ba414fa6146101c4578063e20c9f71146101dc575f5ffd5b806385226c811461018a578063916a17c61461019f578063b0464fdc146101b4578063b5508aa9146101bc575f5ffd5b80633e5e3c23116100e85780633e5e3c231461015d5780633f7286f41461016557806366d9a9a01461016d5780636b39641314610182575f5ffd5b80623f2b1d146101185780630a9254e4146101225780631ed7831c1461012a5780632ade388014610148575b5f5ffd5b610120610234565b005b6101206109f5565b610132610a32565b60405161013f9190611ce2565b60405180910390f35b610150610a92565b60405161013f9190611d5b565b610132610bce565b610132610c2c565b610175610c8a565b60405161013f9190611e9e565b610120610e03565b6101926114e5565b60405161013f9190611f1c565b6101a76115b0565b60405161013f9190611f73565b6101a76116a6565b61019261179c565b6101cc611867565b604051901515815260200161013f565b610132611937565b6101206101f2366004612001565b611995565b601f546101cc9060ff1681565b601f5461021c9061010090046001600160a01b031681565b6040516001600160a01b03909116815260200161013f565b5f732ac98db41cbd3172cb7b8fd8a8ab3b91cfe45dcf90505f8160405161025a90611ca1565b6001600160a01b039091168152602001604051809103905ff080158015610283573d5f5f3e3d5ffd5b5090505f737848f0775eebabbf55cb74490ce6d3673e68773a90505f816040516102ac90611cae565b6001600160a01b039091168152602001604051809103905ff0801580156102d5573d5f5f3e3d5ffd5b5090505f83826040516102e790611cbb565b6001600160a01b03928316815291166020820152604001604051809103905ff080158015610317573d5f5f3e3d5ffd5b506040517f06447d5600000000000000000000000000000000000000000000000000000000815273999999cf1046e68e36e1aa2e0e07105eddd1f08e6004820152909150737109709ecfa91a80626ff3989d68f67f5b1dd12d906306447d56906024015f604051808303815f87803b158015610391575f5ffd5b505af11580156103a3573d5f5f3e3d5ffd5b5050601f546040517f095ea7b30000000000000000000000000000000000000000000000000000000081526001600160a01b0385811660048301526305f5e1006024830152610100909204909116925063095ea7b391506044016020604051808303815f875af1158015610419573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061043d9190612046565b50601f54604080516020810182525f815290517f7f814f350000000000000000000000000000000000000000000000000000000081526101009092046001600160a01b0390811660048401526305f5e10060248401526001604484015290516064830152821690637f814f35906084015f604051808303815f87803b1580156104c4575f5ffd5b505af11580156104d6573d5f5f3e3d5ffd5b50505050737109709ecfa91a80626ff3989d68f67f5b1dd12d6001600160a01b03166390c5013b6040518163ffffffff1660e01b81526004015f604051808303815f87803b158015610526575f5ffd5b505af1158015610538573d5f5f3e3d5ffd5b50506040516370a0823160e01b8152600160048201525f92506001600160a01b03861691506370a0823190602401602060405180830381865afa158015610581573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906105a5919061206c565b90506105e7815f6040518060400160405280601181526020017f5573657220686173207365546f6b656e73000000000000000000000000000000815250611bd1565b601f546040516370a0823160e01b8152600160048201526106969161010090046001600160a01b0316906370a08231906024015b602060405180830381865afa158015610636573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061065a919061206c565b5f6040518060400160405280601781526020017f5573657220686173206e6f205742544320746f6b656e73000000000000000000815250611c4d565b5f866001600160a01b03166359f3d39b6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156106d3573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906106f79190612083565b6040516370a0823160e01b8152600160048201529091506107a1906001600160a01b038316906370a0823190602401602060405180830381865afa158015610741573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610765919061206c565b5f6040518060400160405280601981526020017f5573657220686173206e6f20756e6942544320746f6b656e7300000000000000815250611c4d565b6040517fca669fa700000000000000000000000000000000000000000000000000000000815260016004820152737109709ecfa91a80626ff3989d68f67f5b1dd12d9063ca669fa7906024015f604051808303815f87803b158015610804575f5ffd5b505af1158015610816573d5f5f3e3d5ffd5b50506040517fdb006a75000000000000000000000000000000000000000000000000000000008152600481018590526001600160a01b038816925063db006a7591506024016020604051808303815f875af1158015610877573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061089b919061206c565b506040516370a0823160e01b8152600160048201526001600160a01b038616906370a0823190602401602060405180830381865afa1580156108df573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610903919061206c565b9150610945825f6040518060400160405280601181526020017f55736572206861732072656465656d6564000000000000000000000000000000815250611c4d565b6040516370a0823160e01b8152600160048201526109ec906001600160a01b038316906370a0823190602401602060405180830381865afa15801561098c573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906109b0919061206c565b5f6040518060400160405280601f81526020017f5573657220696e63726561736520696e20756e694254432042616c616e636500815250611bd1565b50505050505050565b610a306269fc8a735a8e9774d67fe846c6f4311c073e2ac34b33646f73999999cf1046e68e36e1aa2e0e07105eddd1f08e6305f5e100611995565b565b60606016805480602002602001604051908101604052809291908181526020018280548015610a8857602002820191905f5260205f20905b81546001600160a01b03168152600190910190602001808311610a6a575b5050505050905090565b6060601e805480602002602001604051908101604052809291908181526020015f905b82821015610bc5575f84815260208082206040805180820182526002870290920180546001600160a01b03168352600181018054835181870281018701909452808452939591948681019491929084015b82821015610bae578382905f5260205f20018054610b239061209e565b80601f0160208091040260200160405190810160405280929190818152602001828054610b4f9061209e565b8015610b9a5780601f10610b7157610100808354040283529160200191610b9a565b820191905f5260205f20905b815481529060010190602001808311610b7d57829003601f168201915b505050505081526020019060010190610b06565b505050508152505081526020019060010190610ab5565b50505050905090565b60606018805480602002602001604051908101604052809291908181526020018280548015610a8857602002820191905f5260205f209081546001600160a01b03168152600190910190602001808311610a6a575050505050905090565b60606017805480602002602001604051908101604052809291908181526020018280548015610a8857602002820191905f5260205f209081546001600160a01b03168152600190910190602001808311610a6a575050505050905090565b6060601b805480602002602001604051908101604052809291908181526020015f905b82821015610bc5578382905f5260205f2090600202016040518060400160405290815f82018054610cdd9061209e565b80601f0160208091040260200160405190810160405280929190818152602001828054610d099061209e565b8015610d545780601f10610d2b57610100808354040283529160200191610d54565b820191905f5260205f20905b815481529060010190602001808311610d3757829003601f168201915b5050505050815260200160018201805480602002602001604051908101604052809291908181526020018280548015610deb57602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191681526020019060040190602082600301049283019260010382029150808411610d985790505b50505050508152505081526020019060010190610cad565b5f73541fd749419ca806a8bc7da8ac23d346f2df8b7790505f73cc0966d8418d412c599a6421b760a847eb169a8c90505f7349b072158564db36304518ffa37b1cfc13916a9073ba46fcc16b464d9787314167bdd9f1ce28405ba17f5664520240a46b4b3e9655c20cc3f9e08496a9b746a478e476ae3e04d6c8fc317f6899a7e13b655fa367208cb27c6eaa2410370d1565dc1f5f11853a1e8cbef0338686604051610eae90611cc8565b6001600160a01b0396871681529486166020860152604085019390935260608401919091528316608083015290911660a082015260c001604051809103905ff080158015610efe573d5f5f3e3d5ffd5b5090505f735ef2b8fbcc8aea2a9dbe2729f0acf33e073fa43e90505f81604051610f2790611cae565b6001600160a01b039091168152602001604051809103905ff080158015610f50573d5f5f3e3d5ffd5b5090505f8382604051610f6290611cd5565b6001600160a01b03928316815291166020820152604001604051809103905ff080158015610f92573d5f5f3e3d5ffd5b506040517f06447d5600000000000000000000000000000000000000000000000000000000815273999999cf1046e68e36e1aa2e0e07105eddd1f08e6004820152909150737109709ecfa91a80626ff3989d68f67f5b1dd12d906306447d56906024015f604051808303815f87803b15801561100c575f5ffd5b505af115801561101e573d5f5f3e3d5ffd5b5050601f546040517f095ea7b30000000000000000000000000000000000000000000000000000000081526001600160a01b0385811660048301526305f5e1006024830152610100909204909116925063095ea7b391506044016020604051808303815f875af1158015611094573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906110b89190612046565b50601f54604080516020810182525f815290517f7f814f350000000000000000000000000000000000000000000000000000000081526101009092046001600160a01b0390811660048401526305f5e10060248401526001604484015290516064830152821690637f814f35906084015f604051808303815f87803b15801561113f575f5ffd5b505af1158015611151573d5f5f3e3d5ffd5b50505050737109709ecfa91a80626ff3989d68f67f5b1dd12d6001600160a01b03166390c5013b6040518163ffffffff1660e01b81526004015f604051808303815f87803b1580156111a1575f5ffd5b505af11580156111b3573d5f5f3e3d5ffd5b50506040516370a0823160e01b8152600160048201525f92506001600160a01b03861691506370a0823190602401602060405180830381865afa1580156111fc573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611220919061206c565b9050611262815f6040518060400160405280601181526020017f5573657220686173207365546f6b656e73000000000000000000000000000000815250611bd1565b601f546040516370a0823160e01b81526001600482015261129a9161010090046001600160a01b0316906370a082319060240161061b565b6040517fca669fa700000000000000000000000000000000000000000000000000000000815260016004820152737109709ecfa91a80626ff3989d68f67f5b1dd12d9063ca669fa7906024015f604051808303815f87803b1580156112fd575f5ffd5b505af115801561130f573d5f5f3e3d5ffd5b50506040517fdb006a75000000000000000000000000000000000000000000000000000000008152600481018490526001600160a01b038716925063db006a7591506024016020604051808303815f875af1158015611370573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611394919061206c565b506040516370a0823160e01b8152600160048201526001600160a01b038516906370a0823190602401602060405180830381865afa1580156113d8573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906113fc919061206c565b905061143e815f6040518060400160405280601181526020017f55736572206861732072656465656d6564000000000000000000000000000000815250611c4d565b6040516370a0823160e01b8152600160048201526109ec906001600160a01b038816906370a0823190602401602060405180830381865afa158015611485573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906114a9919061206c565b5f6040518060400160405280601b81526020017f557365722068617320536f6c764254432e42424e20746f6b656e730000000000815250611bd1565b6060601a805480602002602001604051908101604052809291908181526020015f905b82821015610bc5578382905f5260205f200180546115259061209e565b80601f01602080910402602001604051908101604052809291908181526020018280546115519061209e565b801561159c5780601f106115735761010080835404028352916020019161159c565b820191905f5260205f20905b81548152906001019060200180831161157f57829003601f168201915b505050505081526020019060010190611508565b6060601d805480602002602001604051908101604052809291908181526020015f905b82821015610bc5575f8481526020908190206040805180820182526002860290920180546001600160a01b0316835260018101805483518187028101870190945280845293949193858301939283018282801561168e57602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19168152602001906004019060208260030104928301926001038202915080841161163b5790505b505050505081525050815260200190600101906115d3565b6060601c805480602002602001604051908101604052809291908181526020015f905b82821015610bc5575f8481526020908190206040805180820182526002860290920180546001600160a01b0316835260018101805483518187028101870190945280845293949193858301939283018282801561178457602002820191905f5260205f20905f905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916815260200190600401906020826003010492830192600103820291508084116117315790505b505050505081525050815260200190600101906116c9565b60606019805480602002602001604051908101604052809291908181526020015f905b82821015610bc5578382905f5260205f200180546117dc9061209e565b80601f01602080910402602001604051908101604052809291908181526020018280546118089061209e565b80156118535780601f1061182a57610100808354040283529160200191611853565b820191905f5260205f20905b81548152906001019060200180831161183657829003601f168201915b5050505050815260200190600101906117bf565b6008545f9060ff161561187e575060085460ff1690565b6040517f667f9d70000000000000000000000000000000000000000000000000000000008152737109709ecfa91a80626ff3989d68f67f5b1dd12d600482018190527f6661696c6564000000000000000000000000000000000000000000000000000060248301525f9163667f9d7090604401602060405180830381865afa15801561190c573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611930919061206c565b1415905090565b60606015805480602002602001604051908101604052809291908181526020018280548015610a8857602002820191905f5260205f209081546001600160a01b03168152600190910190602001808311610a6a575050505050905090565b6040517ff877cb1900000000000000000000000000000000000000000000000000000000815260206004820152601760248201527f424f425f50524f445f5055424c49435f5250435f55524c0000000000000000006044820152737109709ecfa91a80626ff3989d68f67f5b1dd12d906371ee464d90829063f877cb19906064015f60405180830381865afa158015611a30573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d908101601f19168201604052611a57919081019061211c565b866040518363ffffffff1660e01b8152600401611a759291906121d0565b6020604051808303815f875af1158015611a91573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611ab5919061206c565b506040517fca669fa70000000000000000000000000000000000000000000000000000000081526001600160a01b0384166004820152737109709ecfa91a80626ff3989d68f67f5b1dd12d9063ca669fa7906024015f604051808303815f87803b158015611b21575f5ffd5b505af1158015611b33573d5f5f3e3d5ffd5b5050601f546040517fa9059cbb0000000000000000000000000000000000000000000000000000000081526001600160a01b03868116600483015260248201869052610100909204909116925063a9059cbb91506044016020604051808303815f875af1158015611ba6573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611bca9190612046565b5050505050565b6040517fd9a3c4d2000000000000000000000000000000000000000000000000000000008152737109709ecfa91a80626ff3989d68f67f5b1dd12d9063d9a3c4d290611c25908690869086906004016121f1565b5f6040518083038186803b158015611c3b575f5ffd5b505afa1580156109ec573d5f5f3e3d5ffd5b6040517f88b44c85000000000000000000000000000000000000000000000000000000008152737109709ecfa91a80626ff3989d68f67f5b1dd12d906388b44c8590611c25908690869086906004016121f1565b610cd48061221983390190565b610cc680612eed83390190565b610d8c80613bb383390190565b610f2d8061493f83390190565b610d208061586c83390190565b602080825282518282018190525f918401906040840190835b81811015611d225783516001600160a01b0316835260209384019390920191600101611cfb565b509095945050505050565b5f81518084528060208401602086015e5f602082860101526020601f19601f83011685010191505092915050565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b82811015611e3657603f19878603018452815180516001600160a01b03168652602090810151604082880181905281519088018190529101906060600582901b8801810191908801905f5b81811015611e1c577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa08a8503018352611e06848651611d2d565b6020958601959094509290920191600101611dcc565b509197505050602094850194929092019150600101611d81565b50929695505050505050565b5f8151808452602084019350602083015f5b82811015611e945781517fffffffff0000000000000000000000000000000000000000000000000000000016865260209586019590910190600101611e54565b5093949350505050565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b82811015611e3657603f198786030184528151805160408752611eea6040880182611d2d565b9050602082015191508681036020880152611f058183611e42565b965050506020938401939190910190600101611ec4565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b82811015611e3657603f19878603018452611f5e858351611d2d565b94506020938401939190910190600101611f42565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b82811015611e3657603f1987860301845281516001600160a01b0381511686526020810151905060406020870152611fd46040870182611e42565b9550506020938401939190910190600101611f99565b6001600160a01b0381168114611ffe575f5ffd5b50565b5f5f5f5f60808587031215612014575f5ffd5b84359350602085013561202681611fea565b9250604085013561203681611fea565b9396929550929360600135925050565b5f60208284031215612056575f5ffd5b81518015158114612065575f5ffd5b9392505050565b5f6020828403121561207c575f5ffd5b5051919050565b5f60208284031215612093575f5ffd5b815161206581611fea565b600181811c908216806120b257607f821691505b6020821081036120e9577f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b50919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b5f6020828403121561212c575f5ffd5b815167ffffffffffffffff811115612142575f5ffd5b8201601f81018413612152575f5ffd5b805167ffffffffffffffff81111561216c5761216c6120ef565b604051601f19603f601f19601f8501160116810181811067ffffffffffffffff8211171561219c5761219c6120ef565b6040528181528282016020018610156121b3575f5ffd5b8160208401602083015e5f91810160200191909152949350505050565b604081525f6121e26040830185611d2d565b90508260208301529392505050565b838152826020820152606060408201525f61220f6060830184611d2d565b9594505050505056fe60a060405234801561000f575f5ffd5b50604051610cd4380380610cd483398101604081905261002e9161003f565b6001600160a01b031660805261006c565b5f6020828403121561004f575f5ffd5b81516001600160a01b0381168114610065575f5ffd5b9392505050565b608051610c3c6100985f395f81816070015281816101230152818161019401526101ee0152610c3c5ff3fe608060405234801561000f575f5ffd5b506004361061003f575f3560e01c806350634c0e146100435780637f814f3514610058578063fbfa77cf1461006b575b5f5ffd5b6100566100513660046109c2565b6100bb565b005b610056610066366004610a84565b6100e5565b6100927f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200160405180910390f35b5f818060200190518101906100d09190610b08565b90506100de858585846100e5565b5050505050565b61010773ffffffffffffffffffffffffffffffffffffffff85163330866103f5565b61014873ffffffffffffffffffffffffffffffffffffffff85167f0000000000000000000000000000000000000000000000000000000000000000856104b9565b6040517f40c10f1900000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8581166004830152602482018590527f000000000000000000000000000000000000000000000000000000000000000016906340c10f19906044015f604051808303815f87803b1580156101d5575f5ffd5b505af11580156101e7573d5f5f3e3d5ffd5b505050505f7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166359f3d39b6040518163ffffffff1660e01b8152600401602060405180830381865afa158015610255573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906102799190610b2c565b6040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201529091505f9073ffffffffffffffffffffffffffffffffffffffff8316906370a0823190602401602060405180830381865afa1580156102e6573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061030a9190610b47565b835190915081101561037d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601a60248201527f496e73756666696369656e74206f757470757420616d6f756e7400000000000060448201526064015b60405180910390fd5b61039e73ffffffffffffffffffffffffffffffffffffffff831685836105b4565b6040805173ffffffffffffffffffffffffffffffffffffffff84168152602081018390527f0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d910160405180910390a1505050505050565b60405173ffffffffffffffffffffffffffffffffffffffff808516602483015283166044820152606481018290526104b39085907f23b872dd00000000000000000000000000000000000000000000000000000000906084015b60408051601f198184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff000000000000000000000000000000000000000000000000000000009093169290921790915261060f565b50505050565b6040517fdd62ed3e00000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff83811660248301525f91839186169063dd62ed3e90604401602060405180830381865afa15801561052d573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906105519190610b47565b61055b9190610b5e565b60405173ffffffffffffffffffffffffffffffffffffffff85166024820152604481018290529091506104b39085907f095ea7b3000000000000000000000000000000000000000000000000000000009060640161044f565b60405173ffffffffffffffffffffffffffffffffffffffff831660248201526044810182905261060a9084907fa9059cbb000000000000000000000000000000000000000000000000000000009060640161044f565b505050565b5f610670826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff1661071a9092919063ffffffff16565b80519091501561060a578080602001905181019061068e9190610b9c565b61060a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f742073756363656564000000000000000000000000000000000000000000006064820152608401610374565b606061072884845f85610732565b90505b9392505050565b6060824710156107c4576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c00000000000000000000000000000000000000000000000000006064820152608401610374565b73ffffffffffffffffffffffffffffffffffffffff85163b610842576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606401610374565b5f5f8673ffffffffffffffffffffffffffffffffffffffff16858760405161086a9190610bbb565b5f6040518083038185875af1925050503d805f81146108a4576040519150601f19603f3d011682016040523d82523d5f602084013e6108a9565b606091505b50915091506108b98282866108c4565b979650505050505050565b606083156108d357508161072b565b8251156108e35782518084602001fd5b816040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016103749190610bd1565b73ffffffffffffffffffffffffffffffffffffffff81168114610938575f5ffd5b50565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b6040516020810167ffffffffffffffff8111828210171561098b5761098b61093b565b60405290565b604051601f8201601f1916810167ffffffffffffffff811182821017156109ba576109ba61093b565b604052919050565b5f5f5f5f608085870312156109d5575f5ffd5b84356109e081610917565b93506020850135925060408501356109f781610917565b9150606085013567ffffffffffffffff811115610a12575f5ffd5b8501601f81018713610a22575f5ffd5b803567ffffffffffffffff811115610a3c57610a3c61093b565b610a4f6020601f19601f84011601610991565b818152886020838501011115610a63575f5ffd5b816020840160208301375f6020838301015280935050505092959194509250565b5f5f5f5f8486036080811215610a98575f5ffd5b8535610aa381610917565b9450602086013593506040860135610aba81610917565b925060207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa082011215610aeb575f5ffd5b50610af4610968565b606095909501358552509194909350909190565b5f6020828403128015610b19575f5ffd5b50610b22610968565b9151825250919050565b5f60208284031215610b3c575f5ffd5b815161072b81610917565b5f60208284031215610b57575f5ffd5b5051919050565b80820180821115610b96577f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b92915050565b5f60208284031215610bac575f5ffd5b8151801515811461072b575f5ffd5b5f82518060208501845e5f920191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f8301168401019150509291505056fea26469706673582212208e1b0cef4a7ed003740a4ee4b7b6f3f4caf8cc471d3e7a392ca4d44b0c1b8d3c64736f6c634300081c003360a060405234801561000f575f5ffd5b50604051610cc6380380610cc683398101604081905261002e9161003f565b6001600160a01b031660805261006c565b5f6020828403121561004f575f5ffd5b81516001600160a01b0381168114610065575f5ffd5b9392505050565b608051610c2e6100985f395f81816048015281816101230152818161018d015261024b0152610c2e5ff3fe608060405234801561000f575f5ffd5b506004361061003f575f3560e01c80631bf7df7b1461004357806350634c0e146100935780637f814f35146100a8575b5f5ffd5b61006a7f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200160405180910390f35b6100a66100a13660046109b4565b6100bb565b005b6100a66100b6366004610a76565b6100e5565b5f818060200190518101906100d09190610afa565b90506100de858585846100e5565b5050505050565b61010773ffffffffffffffffffffffffffffffffffffffff85163330866104a5565b61014873ffffffffffffffffffffffffffffffffffffffff85167f000000000000000000000000000000000000000000000000000000000000000085610569565b6040517f70a0823100000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff83811660048301527f0000000000000000000000000000000000000000000000000000000000000000915f918316906370a0823190602401602060405180830381865afa1580156101d6573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906101fa9190610b1e565b6040517f23323e0300000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8681166004830152602482018890529192505f917f000000000000000000000000000000000000000000000000000000000000000016906323323e03906044016020604051808303815f875af1158015610291573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906102b59190610b1e565b9050801561030a5760405162461bcd60e51b815260206004820152601460248201527f436f756c64206e6f74206d696e7420746f6b656e00000000000000000000000060448201526064015b60405180910390fd5b6040517f70a0823100000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff86811660048301525f91908516906370a0823190602401602060405180830381865afa158015610377573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061039b9190610b1e565b90508281116103ec5760405162461bcd60e51b815260206004820152601c60248201527f496e73756666696369656e7420737570706c792070726f7669646564000000006044820152606401610301565b5f6103f78483610b62565b865190915081101561044b5760405162461bcd60e51b815260206004820152601a60248201527f496e73756666696369656e74206f757470757420616d6f756e740000000000006044820152606401610301565b6040805173ffffffffffffffffffffffffffffffffffffffff87168152602081018390527f0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d910160405180910390a1505050505050505050565b60405173ffffffffffffffffffffffffffffffffffffffff808516602483015283166044820152606481018290526105639085907f23b872dd00000000000000000000000000000000000000000000000000000000906084015b60408051601f198184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff0000000000000000000000000000000000000000000000000000000090931692909217909152610664565b50505050565b6040517fdd62ed3e00000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff83811660248301525f91839186169063dd62ed3e90604401602060405180830381865afa1580156105dd573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906106019190610b1e565b61060b9190610b7b565b60405173ffffffffffffffffffffffffffffffffffffffff85166024820152604481018290529091506105639085907f095ea7b300000000000000000000000000000000000000000000000000000000906064016104ff565b5f6106c5826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff1661075a9092919063ffffffff16565b80519091501561075557808060200190518101906106e39190610b8e565b6107555760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f742073756363656564000000000000000000000000000000000000000000006064820152608401610301565b505050565b606061076884845f85610772565b90505b9392505050565b6060824710156107ea5760405162461bcd60e51b815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c00000000000000000000000000000000000000000000000000006064820152608401610301565b73ffffffffffffffffffffffffffffffffffffffff85163b61084e5760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606401610301565b5f5f8673ffffffffffffffffffffffffffffffffffffffff1685876040516108769190610bad565b5f6040518083038185875af1925050503d805f81146108b0576040519150601f19603f3d011682016040523d82523d5f602084013e6108b5565b606091505b50915091506108c58282866108d0565b979650505050505050565b606083156108df57508161076b565b8251156108ef5782518084602001fd5b8160405162461bcd60e51b81526004016103019190610bc3565b73ffffffffffffffffffffffffffffffffffffffff8116811461092a575f5ffd5b50565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b6040516020810167ffffffffffffffff8111828210171561097d5761097d61092d565b60405290565b604051601f8201601f1916810167ffffffffffffffff811182821017156109ac576109ac61092d565b604052919050565b5f5f5f5f608085870312156109c7575f5ffd5b84356109d281610909565b93506020850135925060408501356109e981610909565b9150606085013567ffffffffffffffff811115610a04575f5ffd5b8501601f81018713610a14575f5ffd5b803567ffffffffffffffff811115610a2e57610a2e61092d565b610a416020601f19601f84011601610983565b818152886020838501011115610a55575f5ffd5b816020840160208301375f6020838301015280935050505092959194509250565b5f5f5f5f8486036080811215610a8a575f5ffd5b8535610a9581610909565b9450602086013593506040860135610aac81610909565b925060207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa082011215610add575f5ffd5b50610ae661095a565b606095909501358552509194909350909190565b5f6020828403128015610b0b575f5ffd5b50610b1461095a565b9151825250919050565b5f60208284031215610b2e575f5ffd5b5051919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b81810381811115610b7557610b75610b35565b92915050565b80820180821115610b7557610b75610b35565b5f60208284031215610b9e575f5ffd5b8151801515811461076b575f5ffd5b5f82518060208501845e5f920191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f8301168401019150509291505056fea264697066735822122096ef65b79f0d809055931520d9882113a9d5b67b3de4b867756bd8349611702564736f6c634300081c003360c060405234801561000f575f5ffd5b50604051610d8c380380610d8c83398101604081905261002e9161005c565b6001600160a01b039182166080521660a052610094565b6001600160a01b0381168114610059575f5ffd5b50565b5f5f6040838503121561006d575f5ffd5b825161007881610045565b602084015190925061008981610045565b809150509250929050565b60805160a051610cb66100d65f395f818160cb015281816103e1015261046101525f8181605301528181610155015281816101df015261023b0152610cb65ff3fe608060405234801561000f575f5ffd5b506004361061004a575f3560e01c8063231710a51461004e57806350634c0e1461009e5780637f814f35146100b3578063b0f1e375146100c6575b5f5ffd5b6100757f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200160405180910390f35b6100b16100ac366004610a3c565b6100ed565b005b6100b16100c1366004610afe565b610117565b6100757f000000000000000000000000000000000000000000000000000000000000000081565b5f818060200190518101906101029190610b82565b905061011085858584610117565b5050505050565b61013973ffffffffffffffffffffffffffffffffffffffff85163330866104c0565b61017a73ffffffffffffffffffffffffffffffffffffffff85167f000000000000000000000000000000000000000000000000000000000000000085610584565b604080516020810182525f815290517f7f814f3500000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff868116600483015260248201869052306044830152915160648201527f000000000000000000000000000000000000000000000000000000000000000090911690637f814f35906084015f604051808303815f87803b158015610222575f5ffd5b505af1158015610234573d5f5f3e3d5ffd5b505050505f7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663fbfa77cf6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156102a2573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906102c69190610ba6565b73ffffffffffffffffffffffffffffffffffffffff166359f3d39b6040518163ffffffff1660e01b8152600401602060405180830381865afa15801561030e573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103329190610ba6565b6040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201529091505f9073ffffffffffffffffffffffffffffffffffffffff8316906370a0823190602401602060405180830381865afa15801561039f573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103c39190610bc1565b905061040673ffffffffffffffffffffffffffffffffffffffff83167f000000000000000000000000000000000000000000000000000000000000000083610584565b6040517f7f814f3500000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8381166004830152602482018390528581166044830152845160648301527f00000000000000000000000000000000000000000000000000000000000000001690637f814f35906084015f604051808303815f87803b1580156104a2575f5ffd5b505af11580156104b4573d5f5f3e3d5ffd5b50505050505050505050565b60405173ffffffffffffffffffffffffffffffffffffffff8085166024830152831660448201526064810182905261057e9085907f23b872dd00000000000000000000000000000000000000000000000000000000906084015b60408051601f198184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff000000000000000000000000000000000000000000000000000000009093169290921790915261067f565b50505050565b6040517fdd62ed3e00000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff83811660248301525f91839186169063dd62ed3e90604401602060405180830381865afa1580156105f8573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061061c9190610bc1565b6106269190610bd8565b60405173ffffffffffffffffffffffffffffffffffffffff851660248201526044810182905290915061057e9085907f095ea7b3000000000000000000000000000000000000000000000000000000009060640161051a565b5f6106e0826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166107949092919063ffffffff16565b80519091501561078f57808060200190518101906106fe9190610c16565b61078f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f7420737563636565640000000000000000000000000000000000000000000060648201526084015b60405180910390fd5b505050565b60606107a284845f856107ac565b90505b9392505050565b60608247101561083e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c00000000000000000000000000000000000000000000000000006064820152608401610786565b73ffffffffffffffffffffffffffffffffffffffff85163b6108bc576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606401610786565b5f5f8673ffffffffffffffffffffffffffffffffffffffff1685876040516108e49190610c35565b5f6040518083038185875af1925050503d805f811461091e576040519150601f19603f3d011682016040523d82523d5f602084013e610923565b606091505b509150915061093382828661093e565b979650505050505050565b6060831561094d5750816107a5565b82511561095d5782518084602001fd5b816040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107869190610c4b565b73ffffffffffffffffffffffffffffffffffffffff811681146109b2575f5ffd5b50565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b6040516020810167ffffffffffffffff81118282101715610a0557610a056109b5565b60405290565b604051601f8201601f1916810167ffffffffffffffff81118282101715610a3457610a346109b5565b604052919050565b5f5f5f5f60808587031215610a4f575f5ffd5b8435610a5a81610991565b9350602085013592506040850135610a7181610991565b9150606085013567ffffffffffffffff811115610a8c575f5ffd5b8501601f81018713610a9c575f5ffd5b803567ffffffffffffffff811115610ab657610ab66109b5565b610ac96020601f19601f84011601610a0b565b818152886020838501011115610add575f5ffd5b816020840160208301375f6020838301015280935050505092959194509250565b5f5f5f5f8486036080811215610b12575f5ffd5b8535610b1d81610991565b9450602086013593506040860135610b3481610991565b925060207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa082011215610b65575f5ffd5b50610b6e6109e2565b606095909501358552509194909350909190565b5f6020828403128015610b93575f5ffd5b50610b9c6109e2565b9151825250919050565b5f60208284031215610bb6575f5ffd5b81516107a581610991565b5f60208284031215610bd1575f5ffd5b5051919050565b80820180821115610c10577f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b92915050565b5f60208284031215610c26575f5ffd5b815180151581146107a5575f5ffd5b5f82518060208501845e5f920191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f8301168401019150509291505056fea2646970667358221220c86fcd420385e3d8e532964687cc1e6fe7c4698813664327361d71293ba3f67964736f6c634300081c0033610140604052348015610010575f5ffd5b50604051610f2d380380610f2d83398101604081905261002f91610073565b6001600160a01b0395861660805293851660a05260c09290925260e05282166101005216610120526100e3565b6001600160a01b0381168114610070575f5ffd5b50565b5f5f5f5f5f5f60c08789031215610088575f5ffd5b86516100938161005c565b60208801519096506100a48161005c565b6040880151606089015160808a015192975090955093506100c48161005c565b60a08801519092506100d58161005c565b809150509295509295509295565b60805160a05160c05160e0516101005161012051610dc66101675f395f818161012e015281816104fc015261053e01525f8181610155015261035201525f81816101b101526103c101525f818161017c015261028801525f818160df0152818161037401526103f001525f8181608e0152818161023b01526102b70152610dc65ff3fe608060405234801561000f575f5ffd5b5060043610610085575f3560e01c8063ad747de611610058578063ad747de614610129578063b9937ccb14610150578063c8c7f70114610177578063e34cef86146101ac575f5ffd5b806306af019a146100895780634e3df3f4146100da57806350634c0e146101015780637f814f3514610116575b5f5ffd5b6100b07f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020015b60405180910390f35b6100b07f000000000000000000000000000000000000000000000000000000000000000081565b61011461010f366004610b67565b6101d3565b005b610114610124366004610c29565b6101fd565b6100b07f000000000000000000000000000000000000000000000000000000000000000081565b6100b07f000000000000000000000000000000000000000000000000000000000000000081565b61019e7f000000000000000000000000000000000000000000000000000000000000000081565b6040519081526020016100d1565b61019e7f000000000000000000000000000000000000000000000000000000000000000081565b5f818060200190518101906101e89190610cad565b90506101f6858585846101fd565b5050505050565b61021f73ffffffffffffffffffffffffffffffffffffffff851633308661059a565b61026073ffffffffffffffffffffffffffffffffffffffff85167f00000000000000000000000000000000000000000000000000000000000000008561065e565b6040517f6d724ead0000000000000000000000000000000000000000000000000000000081527f00000000000000000000000000000000000000000000000000000000000000006004820152602481018490525f907f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1690636d724ead906044016020604051808303815f875af1158015610312573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103369190610cd1565b905061039973ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000167f00000000000000000000000000000000000000000000000000000000000000008361065e565b6040517f6d724ead0000000000000000000000000000000000000000000000000000000081527f00000000000000000000000000000000000000000000000000000000000000006004820152602481018290525f907f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1690636d724ead906044016020604051808303815f875af115801561044b573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061046f9190610cd1565b83519091508110156104e2576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601a60248201527f496e73756666696369656e74206f757470757420616d6f756e7400000000000060448201526064015b60405180910390fd5b61052373ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000168583610759565b6040805173ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000168152602081018390527f0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d910160405180910390a1505050505050565b60405173ffffffffffffffffffffffffffffffffffffffff808516602483015283166044820152606481018290526106589085907f23b872dd00000000000000000000000000000000000000000000000000000000906084015b60408051601f198184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff00000000000000000000000000000000000000000000000000000000909316929092179091526107b4565b50505050565b6040517fdd62ed3e00000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff83811660248301525f91839186169063dd62ed3e90604401602060405180830381865afa1580156106d2573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906106f69190610cd1565b6107009190610ce8565b60405173ffffffffffffffffffffffffffffffffffffffff85166024820152604481018290529091506106589085907f095ea7b300000000000000000000000000000000000000000000000000000000906064016105f4565b60405173ffffffffffffffffffffffffffffffffffffffff83166024820152604481018290526107af9084907fa9059cbb00000000000000000000000000000000000000000000000000000000906064016105f4565b505050565b5f610815826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166108bf9092919063ffffffff16565b8051909150156107af57808060200190518101906108339190610d26565b6107af576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f7420737563636565640000000000000000000000000000000000000000000060648201526084016104d9565b60606108cd84845f856108d7565b90505b9392505050565b606082471015610969576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c000000000000000000000000000000000000000000000000000060648201526084016104d9565b73ffffffffffffffffffffffffffffffffffffffff85163b6109e7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e747261637400000060448201526064016104d9565b5f5f8673ffffffffffffffffffffffffffffffffffffffff168587604051610a0f9190610d45565b5f6040518083038185875af1925050503d805f8114610a49576040519150601f19603f3d011682016040523d82523d5f602084013e610a4e565b606091505b5091509150610a5e828286610a69565b979650505050505050565b60608315610a785750816108d0565b825115610a885782518084602001fd5b816040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104d99190610d5b565b73ffffffffffffffffffffffffffffffffffffffff81168114610add575f5ffd5b50565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b6040516020810167ffffffffffffffff81118282101715610b3057610b30610ae0565b60405290565b604051601f8201601f1916810167ffffffffffffffff81118282101715610b5f57610b5f610ae0565b604052919050565b5f5f5f5f60808587031215610b7a575f5ffd5b8435610b8581610abc565b9350602085013592506040850135610b9c81610abc565b9150606085013567ffffffffffffffff811115610bb7575f5ffd5b8501601f81018713610bc7575f5ffd5b803567ffffffffffffffff811115610be157610be1610ae0565b610bf46020601f19601f84011601610b36565b818152886020838501011115610c08575f5ffd5b816020840160208301375f6020838301015280935050505092959194509250565b5f5f5f5f8486036080811215610c3d575f5ffd5b8535610c4881610abc565b9450602086013593506040860135610c5f81610abc565b925060207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa082011215610c90575f5ffd5b50610c99610b0d565b606095909501358552509194909350909190565b5f6020828403128015610cbe575f5ffd5b50610cc7610b0d565b9151825250919050565b5f60208284031215610ce1575f5ffd5b5051919050565b80820180821115610d20577f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b92915050565b5f60208284031215610d36575f5ffd5b815180151581146108d0575f5ffd5b5f82518060208501845e5f920191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f8301168401019150509291505056fea2646970667358221220d2388cb3dc7aa6f5a2eb75417d11059be13c8c9eabe5d7eadb1b561f937ff69164736f6c634300081c003360c060405234801561000f575f5ffd5b50604051610d20380380610d2083398101604081905261002e9161005c565b6001600160a01b039182166080521660a052610094565b6001600160a01b0381168114610059575f5ffd5b50565b5f5f6040838503121561006d575f5ffd5b825161007881610045565b602084015190925061008981610045565b809150509250929050565b60805160a051610c4a6100d65f395f8181607b0152818161037501526103f501525f818160cb01528181610155015281816101df015261023b0152610c4a5ff3fe608060405234801561000f575f5ffd5b506004361061004a575f3560e01c806350634c0e1461004e5780637f814f3514610063578063b0f1e37514610076578063f2234cf9146100c6575b5f5ffd5b61006161005c3660046109d0565b6100ed565b005b610061610071366004610a92565b610117565b61009d7f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200160405180910390f35b61009d7f000000000000000000000000000000000000000000000000000000000000000081565b5f818060200190518101906101029190610b16565b905061011085858584610117565b5050505050565b61013973ffffffffffffffffffffffffffffffffffffffff8516333086610454565b61017a73ffffffffffffffffffffffffffffffffffffffff85167f000000000000000000000000000000000000000000000000000000000000000085610518565b604080516020810182525f815290517f7f814f3500000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff868116600483015260248201869052306044830152915160648201527f000000000000000000000000000000000000000000000000000000000000000090911690637f814f35906084015f604051808303815f87803b158015610222575f5ffd5b505af1158015610234573d5f5f3e3d5ffd5b505050505f7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663ad747de66040518163ffffffff1660e01b8152600401602060405180830381865afa1580156102a2573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906102c69190610b3a565b6040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201529091505f9073ffffffffffffffffffffffffffffffffffffffff8316906370a0823190602401602060405180830381865afa158015610333573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103579190610b55565b905061039a73ffffffffffffffffffffffffffffffffffffffff83167f000000000000000000000000000000000000000000000000000000000000000083610518565b6040517f7f814f3500000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8381166004830152602482018390528581166044830152845160648301527f00000000000000000000000000000000000000000000000000000000000000001690637f814f35906084015f604051808303815f87803b158015610436575f5ffd5b505af1158015610448573d5f5f3e3d5ffd5b50505050505050505050565b60405173ffffffffffffffffffffffffffffffffffffffff808516602483015283166044820152606481018290526105129085907f23b872dd00000000000000000000000000000000000000000000000000000000906084015b60408051601f198184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff0000000000000000000000000000000000000000000000000000000090931692909217909152610613565b50505050565b6040517fdd62ed3e00000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff83811660248301525f91839186169063dd62ed3e90604401602060405180830381865afa15801561058c573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906105b09190610b55565b6105ba9190610b6c565b60405173ffffffffffffffffffffffffffffffffffffffff85166024820152604481018290529091506105129085907f095ea7b300000000000000000000000000000000000000000000000000000000906064016104ae565b5f610674826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166107289092919063ffffffff16565b80519091501561072357808060200190518101906106929190610baa565b610723576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f7420737563636565640000000000000000000000000000000000000000000060648201526084015b60405180910390fd5b505050565b606061073684845f85610740565b90505b9392505050565b6060824710156107d2576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c0000000000000000000000000000000000000000000000000000606482015260840161071a565b73ffffffffffffffffffffffffffffffffffffffff85163b610850576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015260640161071a565b5f5f8673ffffffffffffffffffffffffffffffffffffffff1685876040516108789190610bc9565b5f6040518083038185875af1925050503d805f81146108b2576040519150601f19603f3d011682016040523d82523d5f602084013e6108b7565b606091505b50915091506108c78282866108d2565b979650505050505050565b606083156108e1575081610739565b8251156108f15782518084602001fd5b816040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161071a9190610bdf565b73ffffffffffffffffffffffffffffffffffffffff81168114610946575f5ffd5b50565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b6040516020810167ffffffffffffffff8111828210171561099957610999610949565b60405290565b604051601f8201601f1916810167ffffffffffffffff811182821017156109c8576109c8610949565b604052919050565b5f5f5f5f608085870312156109e3575f5ffd5b84356109ee81610925565b9350602085013592506040850135610a0581610925565b9150606085013567ffffffffffffffff811115610a20575f5ffd5b8501601f81018713610a30575f5ffd5b803567ffffffffffffffff811115610a4a57610a4a610949565b610a5d6020601f19601f8401160161099f565b818152886020838501011115610a71575f5ffd5b816020840160208301375f6020838301015280935050505092959194509250565b5f5f5f5f8486036080811215610aa6575f5ffd5b8535610ab181610925565b9450602086013593506040860135610ac881610925565b925060207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa082011215610af9575f5ffd5b50610b02610976565b606095909501358552509194909350909190565b5f6020828403128015610b27575f5ffd5b50610b30610976565b9151825250919050565b5f60208284031215610b4a575f5ffd5b815161073981610925565b5f60208284031215610b65575f5ffd5b5051919050565b80820180821115610ba4577f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b92915050565b5f60208284031215610bba575f5ffd5b81518015158114610739575f5ffd5b5f82518060208501845e5f920191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f8301168401019150509291505056fea2646970667358221220228f0384071974aa66f775c606b7dd8b8a4b71a19e3c3921a2ddc47de1c4da6364736f6c634300081c0033a2646970667358221220526f2ea5b605f86d980b9c6e9632a2c46814cbaf88eb147d29e6fe63201ea5f964736f6c634300081c0033 - /// ``` - #[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\x01\x14W_5`\xE0\x1C\x80c\x85\"l\x81\x11a\0\xADW\x80c\xBAAO\xA6\x11a\0}W\x80c\xF9\xCE\x0EZ\x11a\0cW\x80c\xF9\xCE\x0EZ\x14a\x01\xE4W\x80c\xFAv&\xD4\x14a\x01\xF7W\x80c\xFC\x0CTj\x14a\x02\x04W__\xFD[\x80c\xBAAO\xA6\x14a\x01\xC4W\x80c\xE2\x0C\x9Fq\x14a\x01\xDCW__\xFD[\x80c\x85\"l\x81\x14a\x01\x8AW\x80c\x91j\x17\xC6\x14a\x01\x9FW\x80c\xB0FO\xDC\x14a\x01\xB4W\x80c\xB5P\x8A\xA9\x14a\x01\xBCW__\xFD[\x80c>^<#\x11a\0\xE8W\x80c>^<#\x14a\x01]W\x80c?r\x86\xF4\x14a\x01eW\x80cf\xD9\xA9\xA0\x14a\x01mW\x80ck9d\x13\x14a\x01\x82W__\xFD[\x80b?+\x1D\x14a\x01\x18W\x80c\n\x92T\xE4\x14a\x01\"W\x80c\x1E\xD7\x83\x1C\x14a\x01*W\x80c*\xDE8\x80\x14a\x01HW[__\xFD[a\x01 a\x024V[\0[a\x01 a\t\xF5V[a\x012a\n2V[`@Qa\x01?\x91\x90a\x1C\xE2V[`@Q\x80\x91\x03\x90\xF3[a\x01Pa\n\x92V[`@Qa\x01?\x91\x90a\x1D[V[a\x012a\x0B\xCEV[a\x012a\x0C,V[a\x01ua\x0C\x8AV[`@Qa\x01?\x91\x90a\x1E\x9EV[a\x01 a\x0E\x03V[a\x01\x92a\x14\xE5V[`@Qa\x01?\x91\x90a\x1F\x1CV[a\x01\xA7a\x15\xB0V[`@Qa\x01?\x91\x90a\x1FsV[a\x01\xA7a\x16\xA6V[a\x01\x92a\x17\x9CV[a\x01\xCCa\x18gV[`@Q\x90\x15\x15\x81R` \x01a\x01?V[a\x012a\x197V[a\x01 a\x01\xF26`\x04a \x01V[a\x19\x95V[`\x1FTa\x01\xCC\x90`\xFF\x16\x81V[`\x1FTa\x02\x1C\x90a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01?V[_s*\xC9\x8D\xB4\x1C\xBD1r\xCB{\x8F\xD8\xA8\xAB;\x91\xCF\xE4]\xCF\x90P_\x81`@Qa\x02Z\x90a\x1C\xA1V[`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x02\x83W=__>=_\xFD[P\x90P_sxH\xF0w^\xEB\xAB\xBFU\xCBtI\x0C\xE6\xD3g>hw:\x90P_\x81`@Qa\x02\xAC\x90a\x1C\xAEV[`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x02\xD5W=__>=_\xFD[P\x90P_\x83\x82`@Qa\x02\xE7\x90a\x1C\xBBV[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x03\x17W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x03\x91W__\xFD[PZ\xF1\x15\x80\x15a\x03\xA3W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04\x19W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04=\x91\x90a FV[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xC4W__\xFD[PZ\xF1\x15\x80\x15a\x04\xD6W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05&W__\xFD[PZ\xF1\x15\x80\x15a\x058W=__>=_\xFD[PP`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01R_\x92P`\x01`\x01`\xA0\x1B\x03\x86\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x81W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xA5\x91\x90a lV[\x90Pa\x05\xE7\x81_`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01\x7FUser has seTokens\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1B\xD1V[`\x1FT`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01Ra\x06\x96\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90cp\xA0\x821\x90`$\x01[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x066W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06Z\x91\x90a lV[_`@Q\x80`@\x01`@R\x80`\x17\x81R` \x01\x7FUser has no WBTC tokens\0\0\0\0\0\0\0\0\0\x81RPa\x1CMV[_\x86`\x01`\x01`\xA0\x1B\x03\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD3W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF7\x91\x90a \x83V[`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01R\x90\x91Pa\x07\xA1\x90`\x01`\x01`\xA0\x1B\x03\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07AW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07e\x91\x90a lV[_`@Q\x80`@\x01`@R\x80`\x19\x81R` \x01\x7FUser has no uniBTC tokens\0\0\0\0\0\0\0\x81RPa\x1CMV[`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\x04W__\xFD[PZ\xF1\x15\x80\x15a\x08\x16W=__>=_\xFD[PP`@Q\x7F\xDB\0ju\0\0\0\0\0\0\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`\x01`\xA0\x1B\x03\x88\x16\x92Pc\xDB\0ju\x91P`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x08wW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\x9B\x91\x90a lV[P`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x86\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\xDFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\x03\x91\x90a lV[\x91Pa\tE\x82_`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01\x7FUser has redeemed\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1CMV[`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01Ra\t\xEC\x90`\x01`\x01`\xA0\x1B\x03\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\t\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\xB0\x91\x90a lV[_`@Q\x80`@\x01`@R\x80`\x1F\x81R` \x01\x7FUser increase in uniBTC Balance\0\x81RPa\x1B\xD1V[PPPPPPPV[a\n0bi\xFC\x8AsZ\x8E\x97t\xD6\x7F\xE8F\xC6\xF41\x1C\x07>*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x19\x95V[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\n\x88W` \x02\x82\x01\x91\x90_R` _ \x90[\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\njW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x0B\xAEW\x83\x82\x90_R` _ \x01\x80Ta\x0B#\x90a \x9EV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0BO\x90a \x9EV[\x80\x15a\x0B\x9AW\x80`\x1F\x10a\x0BqWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\x9AV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B}W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0B\x06V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\n\xB5V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\n\x88W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\njWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\n\x88W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\njWPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x0C\xDD\x90a \x9EV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\t\x90a \x9EV[\x80\x15a\rTW\x80`\x1F\x10a\r+Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rTV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r7W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\r\xEBW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\x98W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xADV[_sT\x1F\xD7IA\x9C\xA8\x06\xA8\xBC}\xA8\xAC#\xD3F\xF2\xDF\x8Bw\x90P_s\xCC\tf\xD8A\x8DA,Y\x9Ad!\xB7`\xA8G\xEB\x16\x9A\x8C\x90P_sI\xB0r\x15\x85d\xDB60E\x18\xFF\xA3{\x1C\xFC\x13\x91j\x90s\xBAF\xFC\xC1kFM\x97\x871Ag\xBD\xD9\xF1\xCE(@[\xA1\x7FVdR\x02@\xA4kK>\x96U\xC2\x0C\xC3\xF9\xE0\x84\x96\xA9\xB7F\xA4x\xE4v\xAE>\x04\xD6\xC8\xFC1\x7Fh\x99\xA7\xE1;e_\xA3g \x8C\xB2|n\xAA$\x107\r\x15e\xDC\x1F_\x11\x85:\x1E\x8C\xBE\xF03\x86\x86`@Qa\x0E\xAE\x90a\x1C\xC8V[`\x01`\x01`\xA0\x1B\x03\x96\x87\x16\x81R\x94\x86\x16` \x86\x01R`@\x85\x01\x93\x90\x93R``\x84\x01\x91\x90\x91R\x83\x16`\x80\x83\x01R\x90\x91\x16`\xA0\x82\x01R`\xC0\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x0E\xFEW=__>=_\xFD[P\x90P_s^\xF2\xB8\xFB\xCC\x8A\xEA*\x9D\xBE')\xF0\xAC\xF3>\x07?\xA4>\x90P_\x81`@Qa\x0F'\x90a\x1C\xAEV[`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x0FPW=__>=_\xFD[P\x90P_\x83\x82`@Qa\x0Fb\x90a\x1C\xD5V[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16\x81R\x91\x16` \x82\x01R`@\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x0F\x92W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10\x0CW__\xFD[PZ\xF1\x15\x80\x15a\x10\x1EW=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10\x94W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\xB8\x91\x90a FV[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x11?W__\xFD[PZ\xF1\x15\x80\x15a\x11QW=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x11\xA1W__\xFD[PZ\xF1\x15\x80\x15a\x11\xB3W=__>=_\xFD[PP`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01R_\x92P`\x01`\x01`\xA0\x1B\x03\x86\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\xFCW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12 \x91\x90a lV[\x90Pa\x12b\x81_`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01\x7FUser has seTokens\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1B\xD1V[`\x1FT`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01Ra\x12\x9A\x91a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x90cp\xA0\x821\x90`$\x01a\x06\x1BV[`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12\xFDW__\xFD[PZ\xF1\x15\x80\x15a\x13\x0FW=__>=_\xFD[PP`@Q\x7F\xDB\0ju\0\0\0\0\0\0\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`\x01`\x01`\xA0\x1B\x03\x87\x16\x92Pc\xDB\0ju\x91P`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x13pW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13\x94\x91\x90a lV[P`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x85\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x13\xD8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13\xFC\x91\x90a lV[\x90Pa\x14>\x81_`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01\x7FUser has redeemed\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x1CMV[`@Qcp\xA0\x821`\xE0\x1B\x81R`\x01`\x04\x82\x01Ra\t\xEC\x90`\x01`\x01`\xA0\x1B\x03\x88\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x14\x85W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x14\xA9\x91\x90a lV[_`@Q\x80`@\x01`@R\x80`\x1B\x81R` \x01\x7FUser has SolvBTC.BBN tokens\0\0\0\0\0\x81RPa\x1B\xD1V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W\x83\x82\x90_R` _ \x01\x80Ta\x15%\x90a \x9EV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x15Q\x90a \x9EV[\x80\x15a\x15\x9CW\x80`\x1F\x10a\x15sWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x15\x9CV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x15\x7FW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x15\x08V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x16\x8EW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x16;W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x15\xD3V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x17\x84W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x171W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x16\xC9V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x0B\xC5W\x83\x82\x90_R` _ \x01\x80Ta\x17\xDC\x90a \x9EV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x18\x08\x90a \x9EV[\x80\x15a\x18SW\x80`\x1F\x10a\x18*Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x18SV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x186W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x17\xBFV[`\x08T_\x90`\xFF\x16\x15a\x18~WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x19\x0CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x190\x91\x90a lV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\n\x88W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\njWPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x1A0W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x1AW\x91\x90\x81\x01\x90a!\x1CV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x1Au\x92\x91\x90a!\xD0V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x1A\x91W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1A\xB5\x91\x90a lV[P`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x1B!W__\xFD[PZ\xF1\x15\x80\x15a\x1B3W=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x1B\xA6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x1B\xCA\x91\x90a FV[PPPPPV[`@Q\x7F\xD9\xA3\xC4\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xD9\xA3\xC4\xD2\x90a\x1C%\x90\x86\x90\x86\x90\x86\x90`\x04\x01a!\xF1V[_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x1C;W__\xFD[PZ\xFA\x15\x80\x15a\t\xECW=__>=_\xFD[`@Q\x7F\x88\xB4L\x85\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x88\xB4L\x85\x90a\x1C%\x90\x86\x90\x86\x90\x86\x90`\x04\x01a!\xF1V[a\x0C\xD4\x80a\"\x19\x839\x01\x90V[a\x0C\xC6\x80a.\xED\x839\x01\x90V[a\r\x8C\x80a;\xB3\x839\x01\x90V[a\x0F-\x80aI?\x839\x01\x90V[a\r \x80aXl\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x1D\"W\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x1C\xFBV[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1E6W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`\x01`\x01`\xA0\x1B\x03\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x1E\x1CW\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x1E\x06\x84\x86Qa\x1D-V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x1D\xCCV[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x1D\x81V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x1E\x94W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x1ETV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1E6W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x1E\xEA`@\x88\x01\x82a\x1D-V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x1F\x05\x81\x83a\x1EBV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1E\xC4V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1E6W`?\x19\x87\x86\x03\x01\x84Ra\x1F^\x85\x83Qa\x1D-V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1FBV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x1E6W`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x1F\xD4`@\x87\x01\x82a\x1EBV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x1F\x99V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x1F\xFEW__\xFD[PV[____`\x80\x85\x87\x03\x12\x15a \x14W__\xFD[\x845\x93P` \x85\x015a &\x81a\x1F\xEAV[\x92P`@\x85\x015a 6\x81a\x1F\xEAV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[_` \x82\x84\x03\x12\x15a VW__\xFD[\x81Q\x80\x15\x15\x81\x14a eW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a |W__\xFD[PQ\x91\x90PV[_` \x82\x84\x03\x12\x15a \x93W__\xFD[\x81Qa e\x81a\x1F\xEAV[`\x01\x81\x81\x1C\x90\x82\x16\x80a \xB2W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a \xE9W\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[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!,W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a!BW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a!RW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a!lWa!la \xEFV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a!\x9CWa!\x9Ca \xEFV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a!\xB3W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a!\xE2`@\x83\x01\x85a\x1D-V[\x90P\x82` \x83\x01R\x93\x92PPPV[\x83\x81R\x82` \x82\x01R```@\x82\x01R_a\"\x0F``\x83\x01\x84a\x1D-V[\x95\x94PPPPPV\xFE`\xA0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x0C\xD48\x03\x80a\x0C\xD4\x839\x81\x01`@\x81\x90Ra\0.\x91a\0?V[`\x01`\x01`\xA0\x1B\x03\x16`\x80Ra\0lV[_` \x82\x84\x03\x12\x15a\0OW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0eW__\xFD[\x93\x92PPPV[`\x80Qa\x0C=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02UW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02y\x91\x90a\x0B,V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xE6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\n\x91\x90a\x0BGV[\x83Q\x90\x91P\x81\x10\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03\x9Es\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x85\x83a\x05\xB4V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\xB3\x90\x85\x90\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\x90`\x84\x01[`@\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\x0FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05-W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05Q\x91\x90a\x0BGV[a\x05[\x91\x90a\x0B^V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\xB3\x90\x85\x90\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\x90`d\x01a\x04OV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x06\n\x90\x84\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\x90`d\x01a\x04OV[PPPV[_a\x06p\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\x07\x1A\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x06\nW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x8E\x91\x90a\x0B\x9CV[a\x06\nW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[``a\x07(\x84\x84_\x85a\x072V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xC4W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08BW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03tV[__\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\x08j\x91\x90a\x0B\xBBV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xA4W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xA9V[``\x91P[P\x91P\x91Pa\x08\xB9\x82\x82\x86a\x08\xC4V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xD3WP\x81a\x07+V[\x82Q\x15a\x08\xE3W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03t\x91\x90a\x0B\xD1V[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\t8W__\xFD[PV[\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\x8BWa\t\x8Ba\t;V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xBAWa\t\xBAa\t;V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xD5W__\xFD[\x845a\t\xE0\x81a\t\x17V[\x93P` \x85\x015\x92P`@\x85\x015a\t\xF7\x81a\t\x17V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x12W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\"W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nz9,\xA4\xD4K\x0C\x1B\x8D=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xFA\x91\x90a\x0B\x1EV[`@Q\x7F#2>\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x88\x90R\x91\x92P_\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\x90c#2>\x03\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02\x91W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xB5\x91\x90a\x0B\x1EV[\x90P\x80\x15a\x03\nW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FCould not mint token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@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\x86\x81\x16`\x04\x83\x01R_\x91\x90\x85\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03wW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x9B\x91\x90a\x0B\x1EV[\x90P\x82\x81\x11a\x03\xECW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[_a\x03\xF7\x84\x83a\x0BbV[\x86Q\x90\x91P\x81\x10\x15a\x04KW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05c\x90\x85\x90\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\x90`\x84\x01[`@\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\x06dV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xDDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x01\x91\x90a\x0B\x1EV[a\x06\x0B\x91\x90a\x0B{V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05c\x90\x85\x90\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\x90`d\x01a\x04\xFFV[_a\x06\xC5\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\x07Z\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07UW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xE3\x91\x90a\x0B\x8EV[a\x07UW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[PPPV[``a\x07h\x84\x84_\x85a\x07rV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xEAW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08NW`@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\x03\x01V[__\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\x08v\x91\x90a\x0B\xADV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB0W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB5V[``\x91P[P\x91P\x91Pa\x08\xC5\x82\x82\x86a\x08\xD0V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xDFWP\x81a\x07kV[\x82Q\x15a\x08\xEFW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\x01\x91\x90a\x0B\xC3V[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\t*W__\xFD[PV[\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}Wa\t}a\t-V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xACWa\t\xACa\t-V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xC7W__\xFD[\x845a\t\xD2\x81a\t\tV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xE9\x81a\t\tV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x04W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x14W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n.Wa\n.a\t-V[a\nA` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x83V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nUW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x8AW__\xFD[\x855a\n\x95\x81a\t\tV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xAC\x81a\t\tV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xDDW__\xFD[Pa\n\xE6a\tZV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x0BW__\xFD[Pa\x0B\x14a\tZV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B.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`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x0BuWa\x0Bua\x0B5V[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0BuWa\x0Bua\x0B5V[_` \x82\x84\x03\x12\x15a\x0B\x9EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07kW__\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\xFE\xA2dipfsX\"\x12 \x96\xEFe\xB7\x9F\r\x80\x90U\x93\x15 \xD9\x88!\x13\xA9\xD5\xB6{=\xE4\xB8guk\xD84\x96\x11p%dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r\x8C8\x03\x80a\r\x8C\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\xB6a\0\xD6_9_\x81\x81`\xCB\x01R\x81\x81a\x03\xE1\x01Ra\x04a\x01R_\x81\x81`S\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0C\xB6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c#\x17\x10\xA5\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xB0\xF1\xE3u\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\n=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFB\xFAw\xCF`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B\xA6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x0EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x032\x91\x90a\x0B\xA6V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xC3\x91\x90a\x0B\xC1V[\x90Pa\x04\x06s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x84V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xA2W__\xFD[PZ\xF1\x15\x80\x15a\x04\xB4W=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05~\x90\x85\x90\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\x90`\x84\x01[`@\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\x7FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1C\x91\x90a\x0B\xC1V[a\x06&\x91\x90a\x0B\xD8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05~\x90\x85\x90\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\x90`d\x01a\x05\x1AV[_a\x06\xE0\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\x07\x94\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\x8FW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFE\x91\x90a\x0C\x16V[a\x07\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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x07\xA2\x84\x84_\x85a\x07\xACV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08>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\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\x07\x86V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\xBCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x86V[__\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\x08\xE4\x91\x90a\x0C5V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\t\x1EW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t#V[``\x91P[P\x91P\x91Pa\t3\x82\x82\x86a\t>V[\x97\x96PPPPPPPV[``\x83\x15a\tMWP\x81a\x07\xA5V[\x82Q\x15a\t]W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x86\x91\x90a\x0CKV[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\t\xB2W__\xFD[PV[\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\n\x05Wa\n\x05a\t\xB5V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n4Wa\n4a\t\xB5V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\nOW__\xFD[\x845a\nZ\x81a\t\x91V[\x93P` \x85\x015\x92P`@\x85\x015a\nq\x81a\t\x91V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x8CW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x9CW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xB6Wa\n\xB6a\t\xB5V[a\n\xC9` `\x1F\x19`\x1F\x84\x01\x16\x01a\n\x0BV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n\xDDW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0B\x12W__\xFD[\x855a\x0B\x1D\x81a\t\x91V[\x94P` \x86\x015\x93P`@\x86\x015a\x0B4\x81a\t\x91V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0BeW__\xFD[Pa\x0Bna\t\xE2V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x93W__\xFD[Pa\x0B\x9Ca\t\xE2V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xB6W__\xFD[\x81Qa\x07\xA5\x81a\t\x91V[_` \x82\x84\x03\x12\x15a\x0B\xD1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0C\x10W\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[_` \x82\x84\x03\x12\x15a\x0C&W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\xA5W__\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\xFE\xA2dipfsX\"\x12 \xC8o\xCDB\x03\x85\xE3\xD8\xE52\x96F\x87\xCC\x1Eo\xE7\xC4i\x88\x13fC'6\x1Dq);\xA3\xF6ydsolcC\0\x08\x1C\x003a\x01@`@R4\x80\x15a\0\x10W__\xFD[P`@Qa\x0F-8\x03\x80a\x0F-\x839\x81\x01`@\x81\x90Ra\0/\x91a\0sV[`\x01`\x01`\xA0\x1B\x03\x95\x86\x16`\x80R\x93\x85\x16`\xA0R`\xC0\x92\x90\x92R`\xE0R\x82\x16a\x01\0R\x16a\x01 Ra\0\xE3V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0pW__\xFD[PV[______`\xC0\x87\x89\x03\x12\x15a\0\x88W__\xFD[\x86Qa\0\x93\x81a\0\\V[` \x88\x01Q\x90\x96Pa\0\xA4\x81a\0\\V[`@\x88\x01Q``\x89\x01Q`\x80\x8A\x01Q\x92\x97P\x90\x95P\x93Pa\0\xC4\x81a\0\\V[`\xA0\x88\x01Q\x90\x92Pa\0\xD5\x81a\0\\V[\x80\x91PP\x92\x95P\x92\x95P\x92\x95V[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\r\xC6a\x01g_9_\x81\x81a\x01.\x01R\x81\x81a\x04\xFC\x01Ra\x05>\x01R_\x81\x81a\x01U\x01Ra\x03R\x01R_\x81\x81a\x01\xB1\x01Ra\x03\xC1\x01R_\x81\x81a\x01|\x01Ra\x02\x88\x01R_\x81\x81`\xDF\x01R\x81\x81a\x03t\x01Ra\x03\xF0\x01R_\x81\x81`\x8E\x01R\x81\x81a\x02;\x01Ra\x02\xB7\x01Ra\r\xC6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\x85W_5`\xE0\x1C\x80c\xADt}\xE6\x11a\0XW\x80c\xADt}\xE6\x14a\x01)W\x80c\xB9\x93|\xCB\x14a\x01PW\x80c\xC8\xC7\xF7\x01\x14a\x01wW\x80c\xE3L\xEF\x86\x14a\x01\xACW__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0\x89W\x80cN=\xF3\xF4\x14a\0\xDAW\x80cPcL\x0E\x14a\x01\x01W\x80c\x7F\x81O5\x14a\x01\x16W[__\xFD[a\0\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\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\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\x81V[a\x01\x14a\x01\x0F6`\x04a\x0BgV[a\x01\xD3V[\0[a\x01\x14a\x01$6`\x04a\x0C)V[a\x01\xFDV[a\0\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\x81V[a\0\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\x81V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xD1V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\xE8\x91\x90a\x0C\xADV[\x90Pa\x01\xF6\x85\x85\x85\x84a\x01\xFDV[PPPPPV[a\x02\x1Fs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x9AV[a\x02`s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x036\x91\x90a\x0C\xD1V[\x90Pa\x03\x99s\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\x7F\0\0\0\0\0\0\0\0\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\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x82\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04KW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04o\x91\x90a\x0C\xD1V[\x83Q\x90\x91P\x81\x10\x15a\x04\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[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\x85\x83a\x07YV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x06X\x90\x85\x90\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\x90`\x84\x01[`@\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\x07\xB4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF6\x91\x90a\x0C\xD1V[a\x07\0\x91\x90a\x0C\xE8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x06X\x90\x85\x90\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\x90`d\x01a\x05\xF4V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07\xAF\x90\x84\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\x90`d\x01a\x05\xF4V[PPPV[_a\x08\x15\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\x08\xBF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\xAFW\x80\x80` \x01\x90Q\x81\x01\x90a\x083\x91\x90a\r&V[a\x07\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\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\x04\xD9V[``a\x08\xCD\x84\x84_\x85a\x08\xD7V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\tiW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x04\xD9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\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`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x04\xD9V[__\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\n\x0F\x91\x90a\rEV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\nIW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\nNV[``\x91P[P\x91P\x91Pa\n^\x82\x82\x86a\niV[\x97\x96PPPPPPPV[``\x83\x15a\nxWP\x81a\x08\xD0V[\x82Q\x15a\n\x88W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x04\xD9\x91\x90a\r[V[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\xDDW__\xFD[PV[\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\x0B0Wa\x0B0a\n\xE0V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0B_Wa\x0B_a\n\xE0V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0BzW__\xFD[\x845a\x0B\x85\x81a\n\xBCV[\x93P` \x85\x015\x92P`@\x85\x015a\x0B\x9C\x81a\n\xBCV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xB7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\x0B\xC7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xE1Wa\x0B\xE1a\n\xE0V[a\x0B\xF4` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0B6V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0C\x08W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0C=W__\xFD[\x855a\x0CH\x81a\n\xBCV[\x94P` \x86\x015\x93P`@\x86\x015a\x0C_\x81a\n\xBCV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0C\x90W__\xFD[Pa\x0C\x99a\x0B\rV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0C\xBEW__\xFD[Pa\x0C\xC7a\x0B\rV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C\xE1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\r 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[_` \x82\x84\x03\x12\x15a\r6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x08\xD0W__\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\xFE\xA2dipfsX\"\x12 \xD28\x8C\xB3\xDCz\xA6\xF5\xA2\xEBuA}\x11\x05\x9B\xE1<\x8C\x9E\xAB\xE5\xD7\xEA\xDB\x1BV\x1F\x93\x7F\xF6\x91dsolcC\0\x08\x1C\x003`\xC0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\r 8\x03\x80a\r \x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CJa\0\xD6_9_\x81\x81`{\x01R\x81\x81a\x03u\x01Ra\x03\xF5\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0CJ_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cPcL\x0E\x14a\0NW\x80c\x7F\x81O5\x14a\0cW\x80c\xB0\xF1\xE3u\x14a\0vW\x80c\xF2#L\xF9\x14a\0\xC6W[__\xFD[a\0aa\0\\6`\x04a\t\xD0V[a\0\xEDV[\0[a\0aa\0q6`\x04a\n\x92V[a\x01\x17V[a\0\x9D\x7F\0\0\0\0\0\0\0\0\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\x9D\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 \"\x8F\x03\x84\x07\x19t\xAAf\xF7u\xC6\x06\xB7\xDD\x8B\x8AKq\xA1\x9E<9!\xA2\xDD\xC4}\xE1\xC4\xDAcdsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 Ro.\xA5\xB6\x05\xF8m\x98\x0B\x9Cn\x962\xA2\xC4h\x14\xCB\xAF\x88\xEB\x14})\xE6\xFEc \x1E\xA5\xF9dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. -```solidity -event log(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `setUp()` and selector `0x0a9254e4`. -```solidity -function setUp() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setUpCall; - ///Container type for the return parameters of the [`setUp()`](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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl setUpReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for setUpCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = setUpReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "setUp()"; - const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - setUpReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. -```solidity -function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferCall { - #[allow(missing_docs)] - pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub sender: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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::Uint<256>, - ); - #[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::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferCall) -> Self { - (value.forkAtBlock, value.sender, value.receiver, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - forkAtBlock: tuple.0, - sender: tuple.1, - receiver: tuple.2, - amount: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl simulateForkAndTransferReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for simulateForkAndTransferCall { - type Parameters<'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::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = simulateForkAndTransferReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; - const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), - ::tokenize( - &self.sender, - ), - ::tokenize( - &self.receiver, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - simulateForkAndTransferReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testSegmentBedrockStrategy()` and selector `0x003f2b1d`. -```solidity -function testSegmentBedrockStrategy() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testSegmentBedrockStrategyCall; - ///Container type for the return parameters of the [`testSegmentBedrockStrategy()`](testSegmentBedrockStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testSegmentBedrockStrategyReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testSegmentBedrockStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testSegmentBedrockStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testSegmentBedrockStrategyReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testSegmentBedrockStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testSegmentBedrockStrategyReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testSegmentBedrockStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testSegmentBedrockStrategyReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testSegmentBedrockStrategy()"; - const SELECTOR: [u8; 4] = [0u8, 63u8, 43u8, 29u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testSegmentBedrockStrategyReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testSegmentSolvLstStrategy()` and selector `0x6b396413`. -```solidity -function testSegmentSolvLstStrategy() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testSegmentSolvLstStrategyCall; - ///Container type for the return parameters of the [`testSegmentSolvLstStrategy()`](testSegmentSolvLstStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testSegmentSolvLstStrategyReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testSegmentSolvLstStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testSegmentSolvLstStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testSegmentSolvLstStrategyReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testSegmentSolvLstStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testSegmentSolvLstStrategyReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testSegmentSolvLstStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testSegmentSolvLstStrategyReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testSegmentSolvLstStrategy()"; - const SELECTOR: [u8; 4] = [107u8, 57u8, 100u8, 19u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testSegmentSolvLstStrategyReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `token()` and selector `0xfc0c546a`. -```solidity -function token() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`token()`](tokenCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for tokenCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "token()"; - const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`SegmentBedrockAndLstStrategyForked`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum SegmentBedrockAndLstStrategyForkedCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - setUp(setUpCall), - #[allow(missing_docs)] - simulateForkAndTransfer(simulateForkAndTransferCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - testSegmentBedrockStrategy(testSegmentBedrockStrategyCall), - #[allow(missing_docs)] - testSegmentSolvLstStrategy(testSegmentSolvLstStrategyCall), - #[allow(missing_docs)] - token(tokenCall), - } - #[automatically_derived] - impl SegmentBedrockAndLstStrategyForkedCalls { - /// 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, 63u8, 43u8, 29u8], - [10u8, 146u8, 84u8, 228u8], - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [102u8, 217u8, 169u8, 160u8], - [107u8, 57u8, 100u8, 19u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [226u8, 12u8, 159u8, 113u8], - [249u8, 206u8, 14u8, 90u8], - [250u8, 118u8, 38u8, 212u8], - [252u8, 12u8, 84u8, 106u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for SegmentBedrockAndLstStrategyForkedCalls { - const NAME: &'static str = "SegmentBedrockAndLstStrategyForkedCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 17usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::setUp(_) => ::SELECTOR, - Self::simulateForkAndTransfer(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::testSegmentBedrockStrategy(_) => { - ::SELECTOR - } - Self::testSegmentSolvLstStrategy(_) => { - ::SELECTOR - } - Self::token(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn testSegmentBedrockStrategy( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - SegmentBedrockAndLstStrategyForkedCalls::testSegmentBedrockStrategy, - ) - } - testSegmentBedrockStrategy - }, - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw(data) - .map(SegmentBedrockAndLstStrategyForkedCalls::setUp) - } - setUp - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw( - data, - ) - .map(SegmentBedrockAndLstStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - SegmentBedrockAndLstStrategyForkedCalls::targetInterfaces, - ) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw( - data, - ) - .map(SegmentBedrockAndLstStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - SegmentBedrockAndLstStrategyForkedCalls::targetContracts, - ) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - SegmentBedrockAndLstStrategyForkedCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn testSegmentSolvLstStrategy( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - SegmentBedrockAndLstStrategyForkedCalls::testSegmentSolvLstStrategy, - ) - } - testSegmentSolvLstStrategy - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - SegmentBedrockAndLstStrategyForkedCalls::targetArtifacts, - ) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - SegmentBedrockAndLstStrategyForkedCalls::targetSelectors, - ) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - SegmentBedrockAndLstStrategyForkedCalls::excludeSelectors, - ) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - SegmentBedrockAndLstStrategyForkedCalls::excludeArtifacts, - ) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw(data) - .map(SegmentBedrockAndLstStrategyForkedCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - SegmentBedrockAndLstStrategyForkedCalls::excludeContracts, - ) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw( - data, - ) - .map( - SegmentBedrockAndLstStrategyForkedCalls::simulateForkAndTransfer, - ) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw(data) - .map(SegmentBedrockAndLstStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw(data) - .map(SegmentBedrockAndLstStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn testSegmentBedrockStrategy( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - SegmentBedrockAndLstStrategyForkedCalls::testSegmentBedrockStrategy, - ) - } - testSegmentBedrockStrategy - }, - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentBedrockAndLstStrategyForkedCalls::setUp) - } - setUp - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentBedrockAndLstStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - SegmentBedrockAndLstStrategyForkedCalls::targetInterfaces, - ) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentBedrockAndLstStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - SegmentBedrockAndLstStrategyForkedCalls::targetContracts, - ) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - SegmentBedrockAndLstStrategyForkedCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn testSegmentSolvLstStrategy( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - SegmentBedrockAndLstStrategyForkedCalls::testSegmentSolvLstStrategy, - ) - } - testSegmentSolvLstStrategy - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - SegmentBedrockAndLstStrategyForkedCalls::targetArtifacts, - ) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - SegmentBedrockAndLstStrategyForkedCalls::targetSelectors, - ) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - SegmentBedrockAndLstStrategyForkedCalls::excludeSelectors, - ) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - SegmentBedrockAndLstStrategyForkedCalls::excludeArtifacts, - ) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentBedrockAndLstStrategyForkedCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - SegmentBedrockAndLstStrategyForkedCalls::excludeContracts, - ) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map( - SegmentBedrockAndLstStrategyForkedCalls::simulateForkAndTransfer, - ) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentBedrockAndLstStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result< - SegmentBedrockAndLstStrategyForkedCalls, - > { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentBedrockAndLstStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::setUp(inner) => { - ::abi_encoded_size(inner) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testSegmentBedrockStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testSegmentSolvLstStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::token(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::setUp(inner) => { - ::abi_encode_raw(inner, out) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testSegmentBedrockStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testSegmentSolvLstStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::token(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - ///Container for all the [`SegmentBedrockAndLstStrategyForked`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum SegmentBedrockAndLstStrategyForkedEvents { - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl SegmentBedrockAndLstStrategyForkedEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface - for SegmentBedrockAndLstStrategyForkedEvents { - const NAME: &'static str = "SegmentBedrockAndLstStrategyForkedEvents"; - const COUNT: usize = 22usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 SegmentBedrockAndLstStrategyForkedEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`SegmentBedrockAndLstStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`SegmentBedrockAndLstStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> SegmentBedrockAndLstStrategyForkedInstance { - SegmentBedrockAndLstStrategyForkedInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - SegmentBedrockAndLstStrategyForkedInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - SegmentBedrockAndLstStrategyForkedInstance::::deploy_builder(provider) - } - /**A [`SegmentBedrockAndLstStrategyForked`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`SegmentBedrockAndLstStrategyForked`](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 SegmentBedrockAndLstStrategyForkedInstance< - P, - N = alloy_contract::private::Ethereum, - > { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for SegmentBedrockAndLstStrategyForkedInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("SegmentBedrockAndLstStrategyForkedInstance") - .field(&self.address) - .finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SegmentBedrockAndLstStrategyForkedInstance { - /**Creates a new wrapper around an on-chain [`SegmentBedrockAndLstStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`SegmentBedrockAndLstStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 SegmentBedrockAndLstStrategyForkedInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider( - self, - ) -> SegmentBedrockAndLstStrategyForkedInstance { - SegmentBedrockAndLstStrategyForkedInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SegmentBedrockAndLstStrategyForkedInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`setUp`] function. - pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { - self.call_builder(&setUpCall) - } - ///Creates a new call builder for the [`simulateForkAndTransfer`] function. - pub fn simulateForkAndTransfer( - &self, - forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - sender: alloy::sol_types::private::Address, - receiver: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { - self.call_builder( - &simulateForkAndTransferCall { - forkAtBlock, - sender, - receiver, - amount, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`testSegmentBedrockStrategy`] function. - pub fn testSegmentBedrockStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testSegmentBedrockStrategyCall, N> { - self.call_builder(&testSegmentBedrockStrategyCall) - } - ///Creates a new call builder for the [`testSegmentSolvLstStrategy`] function. - pub fn testSegmentSolvLstStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testSegmentSolvLstStrategyCall, N> { - self.call_builder(&testSegmentSolvLstStrategyCall) - } - ///Creates a new call builder for the [`token`] function. - pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { - self.call_builder(&tokenCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SegmentBedrockAndLstStrategyForkedInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/segment_bedrock_strategy.rs b/crates/bindings/src/segment_bedrock_strategy.rs deleted file mode 100644 index b8766c3c9..000000000 --- a/crates/bindings/src/segment_bedrock_strategy.rs +++ /dev/null @@ -1,1810 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface SegmentBedrockStrategy { - struct StrategySlippageArgs { - uint256 amountOutMin; - } - - event TokenOutput(address tokenReceived, uint256 amountOut); - - constructor(address _bedrockStrategy, address _segmentStrategy); - - function bedrockStrategy() external view returns (address); - function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; - function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amount, address recipient, StrategySlippageArgs memory args) external; - function segmentStrategy() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "_bedrockStrategy", - "type": "address", - "internalType": "contract BedrockStrategy" - }, - { - "name": "_segmentStrategy", - "type": "address", - "internalType": "contract SegmentStrategy" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "bedrockStrategy", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract BedrockStrategy" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "handleGatewayMessage", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "message", - "type": "bytes", - "internalType": "bytes" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessageWithSlippageArgs", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "args", - "type": "tuple", - "internalType": "struct StrategySlippageArgs", - "components": [ - { - "name": "amountOutMin", - "type": "uint256", - "internalType": "uint256" - } - ] - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "segmentStrategy", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract SegmentStrategy" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "TokenOutput", - "inputs": [ - { - "name": "tokenReceived", - "type": "address", - "indexed": false, - "internalType": "address" - }, - { - "name": "amountOut", - "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 SegmentBedrockStrategy { - use super::*; - use alloy::sol_types as 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\r\x8C8\x03\x80a\r\x8C\x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0C\xB6a\0\xD6_9_\x81\x81`\xCB\x01R\x81\x81a\x03\xE1\x01Ra\x04a\x01R_\x81\x81`S\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0C\xB6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c#\x17\x10\xA5\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xB0\xF1\xE3u\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\n=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFB\xFAw\xCF`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B\xA6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x0EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x032\x91\x90a\x0B\xA6V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xC3\x91\x90a\x0B\xC1V[\x90Pa\x04\x06s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x84V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xA2W__\xFD[PZ\xF1\x15\x80\x15a\x04\xB4W=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05~\x90\x85\x90\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\x90`\x84\x01[`@\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\x7FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1C\x91\x90a\x0B\xC1V[a\x06&\x91\x90a\x0B\xD8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05~\x90\x85\x90\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\x90`d\x01a\x05\x1AV[_a\x06\xE0\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\x07\x94\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\x8FW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFE\x91\x90a\x0C\x16V[a\x07\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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x07\xA2\x84\x84_\x85a\x07\xACV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08>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\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\x07\x86V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\xBCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x86V[__\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\x08\xE4\x91\x90a\x0C5V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\t\x1EW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t#V[``\x91P[P\x91P\x91Pa\t3\x82\x82\x86a\t>V[\x97\x96PPPPPPPV[``\x83\x15a\tMWP\x81a\x07\xA5V[\x82Q\x15a\t]W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x86\x91\x90a\x0CKV[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\t\xB2W__\xFD[PV[\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\n\x05Wa\n\x05a\t\xB5V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n4Wa\n4a\t\xB5V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\nOW__\xFD[\x845a\nZ\x81a\t\x91V[\x93P` \x85\x015\x92P`@\x85\x015a\nq\x81a\t\x91V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x8CW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x9CW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xB6Wa\n\xB6a\t\xB5V[a\n\xC9` `\x1F\x19`\x1F\x84\x01\x16\x01a\n\x0BV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n\xDDW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0B\x12W__\xFD[\x855a\x0B\x1D\x81a\t\x91V[\x94P` \x86\x015\x93P`@\x86\x015a\x0B4\x81a\t\x91V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0BeW__\xFD[Pa\x0Bna\t\xE2V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x93W__\xFD[Pa\x0B\x9Ca\t\xE2V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xB6W__\xFD[\x81Qa\x07\xA5\x81a\t\x91V[_` \x82\x84\x03\x12\x15a\x0B\xD1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0C\x10W\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[_` \x82\x84\x03\x12\x15a\x0C&W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\xA5W__\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\xFE\xA2dipfsX\"\x12 \xC8o\xCDB\x03\x85\xE3\xD8\xE52\x96F\x87\xCC\x1Eo\xE7\xC4i\x88\x13fC'6\x1Dq);\xA3\xF6ydsolcC\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#\x17\x10\xA5\x14a\0NW\x80cPcL\x0E\x14a\0\x9EW\x80c\x7F\x81O5\x14a\0\xB3W\x80c\xB0\xF1\xE3u\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\n=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xFB\xFAw\xCF`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B\xA6V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16cY\xF3\xD3\x9B`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x0EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x032\x91\x90a\x0B\xA6V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x9FW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xC3\x91\x90a\x0B\xC1V[\x90Pa\x04\x06s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x84V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xA2W__\xFD[PZ\xF1\x15\x80\x15a\x04\xB4W=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05~\x90\x85\x90\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\x90`\x84\x01[`@\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\x7FV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF8W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x1C\x91\x90a\x0B\xC1V[a\x06&\x91\x90a\x0B\xD8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05~\x90\x85\x90\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\x90`d\x01a\x05\x1AV[_a\x06\xE0\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\x07\x94\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\x8FW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xFE\x91\x90a\x0C\x16V[a\x07\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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x07\xA2\x84\x84_\x85a\x07\xACV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x08>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\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\x07\x86V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\xBCW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x86V[__\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\x08\xE4\x91\x90a\x0C5V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\t\x1EW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\t#V[``\x91P[P\x91P\x91Pa\t3\x82\x82\x86a\t>V[\x97\x96PPPPPPPV[``\x83\x15a\tMWP\x81a\x07\xA5V[\x82Q\x15a\t]W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x86\x91\x90a\x0CKV[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\t\xB2W__\xFD[PV[\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\n\x05Wa\n\x05a\t\xB5V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\n4Wa\n4a\t\xB5V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\nOW__\xFD[\x845a\nZ\x81a\t\x91V[\x93P` \x85\x015\x92P`@\x85\x015a\nq\x81a\t\x91V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x8CW__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x9CW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\xB6Wa\n\xB6a\t\xB5V[a\n\xC9` `\x1F\x19`\x1F\x84\x01\x16\x01a\n\x0BV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n\xDDW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0B\x12W__\xFD[\x855a\x0B\x1D\x81a\t\x91V[\x94P` \x86\x015\x93P`@\x86\x015a\x0B4\x81a\t\x91V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0BeW__\xFD[Pa\x0Bna\t\xE2V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x93W__\xFD[Pa\x0B\x9Ca\t\xE2V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\xB6W__\xFD[\x81Qa\x07\xA5\x81a\t\x91V[_` \x82\x84\x03\x12\x15a\x0B\xD1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0C\x10W\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[_` \x82\x84\x03\x12\x15a\x0C&W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\xA5W__\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\xFE\xA2dipfsX\"\x12 \xC8o\xCDB\x03\x85\xE3\xD8\xE52\x96F\x87\xCC\x1Eo\xE7\xC4i\x88\x13fC'6\x1Dq);\xA3\xF6ydsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct StrategySlippageArgs { uint256 amountOutMin; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct StrategySlippageArgs { - #[allow(missing_docs)] - pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: StrategySlippageArgs) -> Self { - (value.amountOutMin,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for StrategySlippageArgs { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { amountOutMin: tuple.0 } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for StrategySlippageArgs { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for StrategySlippageArgs { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for StrategySlippageArgs { - const NAME: &'static str = "StrategySlippageArgs"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "StrategySlippageArgs(uint256 amountOutMin)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) - .0 - .to_vec() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for StrategySlippageArgs { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.amountOutMin, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.amountOutMin, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. -```solidity -event TokenOutput(address tokenReceived, uint256 amountOut); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct TokenOutput { - #[allow(missing_docs)] - pub tokenReceived: alloy::sol_types::private::Address, - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for TokenOutput { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - tokenReceived: data.0, - amountOut: data.1, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.tokenReceived, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountOut), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 TokenOutput { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&TokenOutput> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - /**Constructor`. -```solidity -constructor(address _bedrockStrategy, address _segmentStrategy); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct constructorCall { - #[allow(missing_docs)] - pub _bedrockStrategy: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub _segmentStrategy: alloy::sol_types::private::Address, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value._bedrockStrategy, value._segmentStrategy) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - _bedrockStrategy: tuple.0, - _segmentStrategy: 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> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._bedrockStrategy, - ), - ::tokenize( - &self._segmentStrategy, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `bedrockStrategy()` and selector `0x231710a5`. -```solidity -function bedrockStrategy() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct bedrockStrategyCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`bedrockStrategy()`](bedrockStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct bedrockStrategyReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: bedrockStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for bedrockStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: bedrockStrategyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for bedrockStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for bedrockStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "bedrockStrategy()"; - const SELECTOR: [u8; 4] = [35u8, 23u8, 16u8, 165u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: bedrockStrategyReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: bedrockStrategyReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. -```solidity -function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub message: alloy::sol_types::private::Bytes, - } - ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ); - #[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, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.message) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - message: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageCall { - 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, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; - const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.message, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. -```solidity -function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amount, address recipient, StrategySlippageArgs memory args) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub args: ::RustType, - } - ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::primitives::aliases::U256, - alloy::sol_types::private::Address, - ::RustType, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { - (value.tokenSent, value.amount, value.recipient, value.args) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amount: tuple.1, - recipient: tuple.2, - args: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageWithSlippageArgsReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageWithSlippageArgsReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; - const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.args, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `segmentStrategy()` and selector `0xb0f1e375`. -```solidity -function segmentStrategy() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct segmentStrategyCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`segmentStrategy()`](segmentStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct segmentStrategyReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: segmentStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for segmentStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: segmentStrategyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for segmentStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for segmentStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "segmentStrategy()"; - const SELECTOR: [u8; 4] = [176u8, 241u8, 227u8, 117u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: segmentStrategyReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: segmentStrategyReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`SegmentBedrockStrategy`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum SegmentBedrockStrategyCalls { - #[allow(missing_docs)] - bedrockStrategy(bedrockStrategyCall), - #[allow(missing_docs)] - handleGatewayMessage(handleGatewayMessageCall), - #[allow(missing_docs)] - handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), - #[allow(missing_docs)] - segmentStrategy(segmentStrategyCall), - } - #[automatically_derived] - impl SegmentBedrockStrategyCalls { - /// 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]] = &[ - [35u8, 23u8, 16u8, 165u8], - [80u8, 99u8, 76u8, 14u8], - [127u8, 129u8, 79u8, 53u8], - [176u8, 241u8, 227u8, 117u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for SegmentBedrockStrategyCalls { - const NAME: &'static str = "SegmentBedrockStrategyCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 4usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::bedrockStrategy(_) => { - ::SELECTOR - } - Self::handleGatewayMessage(_) => { - ::SELECTOR - } - Self::handleGatewayMessageWithSlippageArgs(_) => { - ::SELECTOR - } - Self::segmentStrategy(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn bedrockStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SegmentBedrockStrategyCalls::bedrockStrategy) - } - bedrockStrategy - }, - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SegmentBedrockStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - SegmentBedrockStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - { - fn segmentStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SegmentBedrockStrategyCalls::segmentStrategy) - } - segmentStrategy - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn bedrockStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentBedrockStrategyCalls::bedrockStrategy) - } - bedrockStrategy - }, - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentBedrockStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - SegmentBedrockStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - { - fn segmentStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentBedrockStrategyCalls::segmentStrategy) - } - segmentStrategy - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::bedrockStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::handleGatewayMessage(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::segmentStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::bedrockStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::handleGatewayMessage(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::segmentStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`SegmentBedrockStrategy`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum SegmentBedrockStrategyEvents { - #[allow(missing_docs)] - TokenOutput(TokenOutput), - } - #[automatically_derived] - impl SegmentBedrockStrategyEvents { - /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for SegmentBedrockStrategyEvents { - const NAME: &'static str = "SegmentBedrockStrategyEvents"; - const COUNT: usize = 1usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::TokenOutput) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 SegmentBedrockStrategyEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`SegmentBedrockStrategy`](self) contract instance. - -See the [wrapper's documentation](`SegmentBedrockStrategyInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> SegmentBedrockStrategyInstance { - SegmentBedrockStrategyInstance::::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: alloy_contract::private::Network, - >( - provider: P, - _bedrockStrategy: alloy::sol_types::private::Address, - _segmentStrategy: alloy::sol_types::private::Address, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - SegmentBedrockStrategyInstance::< - P, - N, - >::deploy(provider, _bedrockStrategy, _segmentStrategy) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - _bedrockStrategy: alloy::sol_types::private::Address, - _segmentStrategy: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - SegmentBedrockStrategyInstance::< - P, - N, - >::deploy_builder(provider, _bedrockStrategy, _segmentStrategy) - } - /**A [`SegmentBedrockStrategy`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`SegmentBedrockStrategy`](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 SegmentBedrockStrategyInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for SegmentBedrockStrategyInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("SegmentBedrockStrategyInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SegmentBedrockStrategyInstance { - /**Creates a new wrapper around an on-chain [`SegmentBedrockStrategy`](self) contract instance. - -See the [wrapper's documentation](`SegmentBedrockStrategyInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - _bedrockStrategy: alloy::sol_types::private::Address, - _segmentStrategy: alloy::sol_types::private::Address, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder( - provider, - _bedrockStrategy, - _segmentStrategy, - ); - 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, - _bedrockStrategy: alloy::sol_types::private::Address, - _segmentStrategy: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { - _bedrockStrategy, - _segmentStrategy, - }, - )[..], - ] - .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 SegmentBedrockStrategyInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> SegmentBedrockStrategyInstance { - SegmentBedrockStrategyInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SegmentBedrockStrategyInstance { - /// 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( - &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 [`bedrockStrategy`] function. - pub fn bedrockStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, bedrockStrategyCall, N> { - self.call_builder(&bedrockStrategyCall) - } - ///Creates a new call builder for the [`handleGatewayMessage`] function. - pub fn handleGatewayMessage( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - message: alloy::sol_types::private::Bytes, - ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { - self.call_builder( - &handleGatewayMessageCall { - tokenSent, - amountIn, - recipient, - message, - }, - ) - } - ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. - pub fn handleGatewayMessageWithSlippageArgs( - &self, - tokenSent: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - args: ::RustType, - ) -> alloy_contract::SolCallBuilder< - &P, - handleGatewayMessageWithSlippageArgsCall, - N, - > { - self.call_builder( - &handleGatewayMessageWithSlippageArgsCall { - tokenSent, - amount, - recipient, - args, - }, - ) - } - ///Creates a new call builder for the [`segmentStrategy`] function. - pub fn segmentStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, segmentStrategyCall, N> { - self.call_builder(&segmentStrategyCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SegmentBedrockStrategyInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`TokenOutput`] event. - pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/segment_solv_lst_strategy.rs b/crates/bindings/src/segment_solv_lst_strategy.rs deleted file mode 100644 index 748bf9cd5..000000000 --- a/crates/bindings/src/segment_solv_lst_strategy.rs +++ /dev/null @@ -1,1810 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface SegmentSolvLSTStrategy { - struct StrategySlippageArgs { - uint256 amountOutMin; - } - - event TokenOutput(address tokenReceived, uint256 amountOut); - - constructor(address _solvLSTStrategy, address _segmentStrategy); - - function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; - function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amount, address recipient, StrategySlippageArgs memory args) external; - function segmentStrategy() external view returns (address); - function solvLSTStrategy() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "_solvLSTStrategy", - "type": "address", - "internalType": "contract SolvLSTStrategy" - }, - { - "name": "_segmentStrategy", - "type": "address", - "internalType": "contract SegmentStrategy" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessage", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "message", - "type": "bytes", - "internalType": "bytes" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessageWithSlippageArgs", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "args", - "type": "tuple", - "internalType": "struct StrategySlippageArgs", - "components": [ - { - "name": "amountOutMin", - "type": "uint256", - "internalType": "uint256" - } - ] - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "segmentStrategy", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract SegmentStrategy" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "solvLSTStrategy", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract SolvLSTStrategy" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "TokenOutput", - "inputs": [ - { - "name": "tokenReceived", - "type": "address", - "indexed": false, - "internalType": "address" - }, - { - "name": "amountOut", - "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 SegmentSolvLSTStrategy { - use super::*; - use alloy::sol_types as 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\r 8\x03\x80a\r \x839\x81\x01`@\x81\x90Ra\0.\x91a\0\\V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16`\x80R\x16`\xA0Ra\0\x94V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0YW__\xFD[PV[__`@\x83\x85\x03\x12\x15a\0mW__\xFD[\x82Qa\0x\x81a\0EV[` \x84\x01Q\x90\x92Pa\0\x89\x81a\0EV[\x80\x91PP\x92P\x92\x90PV[`\x80Q`\xA0Qa\x0CJa\0\xD6_9_\x81\x81`{\x01R\x81\x81a\x03u\x01Ra\x03\xF5\x01R_\x81\x81`\xCB\x01R\x81\x81a\x01U\x01R\x81\x81a\x01\xDF\x01Ra\x02;\x01Ra\x0CJ_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80cPcL\x0E\x14a\0NW\x80c\x7F\x81O5\x14a\0cW\x80c\xB0\xF1\xE3u\x14a\0vW\x80c\xF2#L\xF9\x14a\0\xC6W[__\xFD[a\0aa\0\\6`\x04a\t\xD0V[a\0\xEDV[\0[a\0aa\0q6`\x04a\n\x92V[a\x01\x17V[a\0\x9D\x7F\0\0\0\0\0\0\0\0\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\x9D\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 \"\x8F\x03\x84\x07\x19t\xAAf\xF7u\xC6\x06\xB7\xDD\x8B\x8AKq\xA1\x9E<9!\xA2\xDD\xC4}\xE1\xC4\xDAcdsolcC\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\x80cPcL\x0E\x14a\0NW\x80c\x7F\x81O5\x14a\0cW\x80c\xB0\xF1\xE3u\x14a\0vW\x80c\xF2#L\xF9\x14a\0\xC6W[__\xFD[a\0aa\0\\6`\x04a\t\xD0V[a\0\xEDV[\0[a\0aa\0q6`\x04a\n\x92V[a\x01\x17V[a\0\x9D\x7F\0\0\0\0\0\0\0\0\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\x9D\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\x02\x91\x90a\x0B\x16V[\x90Pa\x01\x10\x85\x85\x85\x84a\x01\x17V[PPPPPV[a\x019s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04TV[a\x01zs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05\x18V[`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\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\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90R0`D\x83\x01R\x91Q`d\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\x90\x91\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02\"W__\xFD[PZ\xF1\x15\x80\x15a\x024W=__>=_\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\0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xADt}\xE6`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x02\xA2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xC6\x91\x90a\x0B:V[`@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\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x033W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03W\x91\x90a\x0BUV[\x90Pa\x03\x9As\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\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\0\x83a\x05\x18V[`@Q\x7F\x7F\x81O5\0\0\0\0\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\x85\x81\x16`D\x83\x01R\x84Q`d\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\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x046W__\xFD[PZ\xF1\x15\x80\x15a\x04HW=__>=_\xFD[PPPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05\x12\x90\x85\x90\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\x90`\x84\x01[`@\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\x13V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x8CW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\xB0\x91\x90a\x0BUV[a\x05\xBA\x91\x90a\x0BlV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05\x12\x90\x85\x90\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\x90`d\x01a\x04\xAEV[_a\x06t\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\x07(\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07#W\x80\x80` \x01\x90Q\x81\x01\x90a\x06\x92\x91\x90a\x0B\xAAV[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\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\x01[`@Q\x80\x91\x03\x90\xFD[PPPV[``a\x076\x84\x84_\x85a\x07@V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\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\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\x07\x1AV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08PW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x07\x1AV[__\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\x08x\x91\x90a\x0B\xC9V[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB2W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB7V[``\x91P[P\x91P\x91Pa\x08\xC7\x82\x82\x86a\x08\xD2V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xE1WP\x81a\x079V[\x82Q\x15a\x08\xF1W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x07\x1A\x91\x90a\x0B\xDFV[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\tFW__\xFD[PV[\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\x99Wa\t\x99a\tIV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xC8Wa\t\xC8a\tIV[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xE3W__\xFD[\x845a\t\xEE\x81a\t%V[\x93P` \x85\x015\x92P`@\x85\x015a\n\x05\x81a\t%V[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n0W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\nJWa\nJa\tIV[a\n]` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x9FV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nqW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\xA6W__\xFD[\x855a\n\xB1\x81a\t%V[\x94P` \x86\x015\x93P`@\x86\x015a\n\xC8\x81a\t%V[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xF9W__\xFD[Pa\x0B\x02a\tvV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B'W__\xFD[Pa\x0B0a\tvV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0BJW__\xFD[\x81Qa\x079\x81a\t%V[_` \x82\x84\x03\x12\x15a\x0BeW__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0B\xA4W\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[_` \x82\x84\x03\x12\x15a\x0B\xBAW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x079W__\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\xFE\xA2dipfsX\"\x12 \"\x8F\x03\x84\x07\x19t\xAAf\xF7u\xC6\x06\xB7\xDD\x8B\x8AKq\xA1\x9E<9!\xA2\xDD\xC4}\xE1\xC4\xDAcdsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct StrategySlippageArgs { uint256 amountOutMin; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct StrategySlippageArgs { - #[allow(missing_docs)] - pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: StrategySlippageArgs) -> Self { - (value.amountOutMin,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for StrategySlippageArgs { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { amountOutMin: tuple.0 } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for StrategySlippageArgs { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for StrategySlippageArgs { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for StrategySlippageArgs { - const NAME: &'static str = "StrategySlippageArgs"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "StrategySlippageArgs(uint256 amountOutMin)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) - .0 - .to_vec() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for StrategySlippageArgs { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.amountOutMin, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.amountOutMin, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. -```solidity -event TokenOutput(address tokenReceived, uint256 amountOut); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct TokenOutput { - #[allow(missing_docs)] - pub tokenReceived: alloy::sol_types::private::Address, - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for TokenOutput { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - tokenReceived: data.0, - amountOut: data.1, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.tokenReceived, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountOut), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 TokenOutput { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&TokenOutput> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - /**Constructor`. -```solidity -constructor(address _solvLSTStrategy, address _segmentStrategy); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct constructorCall { - #[allow(missing_docs)] - pub _solvLSTStrategy: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub _segmentStrategy: alloy::sol_types::private::Address, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value._solvLSTStrategy, value._segmentStrategy) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - _solvLSTStrategy: tuple.0, - _segmentStrategy: 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> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._solvLSTStrategy, - ), - ::tokenize( - &self._segmentStrategy, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. -```solidity -function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub message: alloy::sol_types::private::Bytes, - } - ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ); - #[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, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.message) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - message: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageCall { - 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, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; - const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.message, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. -```solidity -function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amount, address recipient, StrategySlippageArgs memory args) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amount: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub args: ::RustType, - } - ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::primitives::aliases::U256, - alloy::sol_types::private::Address, - ::RustType, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { - (value.tokenSent, value.amount, value.recipient, value.args) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amount: tuple.1, - recipient: tuple.2, - args: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageWithSlippageArgsReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageWithSlippageArgsReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; - const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.args, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `segmentStrategy()` and selector `0xb0f1e375`. -```solidity -function segmentStrategy() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct segmentStrategyCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`segmentStrategy()`](segmentStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct segmentStrategyReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: segmentStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for segmentStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: segmentStrategyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for segmentStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for segmentStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "segmentStrategy()"; - const SELECTOR: [u8; 4] = [176u8, 241u8, 227u8, 117u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: segmentStrategyReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: segmentStrategyReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `solvLSTStrategy()` and selector `0xf2234cf9`. -```solidity -function solvLSTStrategy() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct solvLSTStrategyCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`solvLSTStrategy()`](solvLSTStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct solvLSTStrategyReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: solvLSTStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for solvLSTStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: solvLSTStrategyReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for solvLSTStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for solvLSTStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "solvLSTStrategy()"; - const SELECTOR: [u8; 4] = [242u8, 35u8, 76u8, 249u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: solvLSTStrategyReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: solvLSTStrategyReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`SegmentSolvLSTStrategy`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum SegmentSolvLSTStrategyCalls { - #[allow(missing_docs)] - handleGatewayMessage(handleGatewayMessageCall), - #[allow(missing_docs)] - handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), - #[allow(missing_docs)] - segmentStrategy(segmentStrategyCall), - #[allow(missing_docs)] - solvLSTStrategy(solvLSTStrategyCall), - } - #[automatically_derived] - impl SegmentSolvLSTStrategyCalls { - /// 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, 99u8, 76u8, 14u8], - [127u8, 129u8, 79u8, 53u8], - [176u8, 241u8, 227u8, 117u8], - [242u8, 35u8, 76u8, 249u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for SegmentSolvLSTStrategyCalls { - const NAME: &'static str = "SegmentSolvLSTStrategyCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 4usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::handleGatewayMessage(_) => { - ::SELECTOR - } - Self::handleGatewayMessageWithSlippageArgs(_) => { - ::SELECTOR - } - Self::segmentStrategy(_) => { - ::SELECTOR - } - Self::solvLSTStrategy(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SegmentSolvLSTStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - SegmentSolvLSTStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - { - fn segmentStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SegmentSolvLSTStrategyCalls::segmentStrategy) - } - segmentStrategy - }, - { - fn solvLSTStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SegmentSolvLSTStrategyCalls::solvLSTStrategy) - } - solvLSTStrategy - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentSolvLSTStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - SegmentSolvLSTStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - { - fn segmentStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentSolvLSTStrategyCalls::segmentStrategy) - } - segmentStrategy - }, - { - fn solvLSTStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentSolvLSTStrategyCalls::solvLSTStrategy) - } - solvLSTStrategy - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::handleGatewayMessage(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::segmentStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::solvLSTStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::handleGatewayMessage(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::segmentStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::solvLSTStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`SegmentSolvLSTStrategy`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum SegmentSolvLSTStrategyEvents { - #[allow(missing_docs)] - TokenOutput(TokenOutput), - } - #[automatically_derived] - impl SegmentSolvLSTStrategyEvents { - /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for SegmentSolvLSTStrategyEvents { - const NAME: &'static str = "SegmentSolvLSTStrategyEvents"; - const COUNT: usize = 1usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::TokenOutput) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 SegmentSolvLSTStrategyEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`SegmentSolvLSTStrategy`](self) contract instance. - -See the [wrapper's documentation](`SegmentSolvLSTStrategyInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> SegmentSolvLSTStrategyInstance { - SegmentSolvLSTStrategyInstance::::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: alloy_contract::private::Network, - >( - provider: P, - _solvLSTStrategy: alloy::sol_types::private::Address, - _segmentStrategy: alloy::sol_types::private::Address, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - SegmentSolvLSTStrategyInstance::< - P, - N, - >::deploy(provider, _solvLSTStrategy, _segmentStrategy) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - _solvLSTStrategy: alloy::sol_types::private::Address, - _segmentStrategy: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - SegmentSolvLSTStrategyInstance::< - P, - N, - >::deploy_builder(provider, _solvLSTStrategy, _segmentStrategy) - } - /**A [`SegmentSolvLSTStrategy`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`SegmentSolvLSTStrategy`](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 SegmentSolvLSTStrategyInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for SegmentSolvLSTStrategyInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("SegmentSolvLSTStrategyInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SegmentSolvLSTStrategyInstance { - /**Creates a new wrapper around an on-chain [`SegmentSolvLSTStrategy`](self) contract instance. - -See the [wrapper's documentation](`SegmentSolvLSTStrategyInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - _solvLSTStrategy: alloy::sol_types::private::Address, - _segmentStrategy: alloy::sol_types::private::Address, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder( - provider, - _solvLSTStrategy, - _segmentStrategy, - ); - 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, - _solvLSTStrategy: alloy::sol_types::private::Address, - _segmentStrategy: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { - _solvLSTStrategy, - _segmentStrategy, - }, - )[..], - ] - .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 SegmentSolvLSTStrategyInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> SegmentSolvLSTStrategyInstance { - SegmentSolvLSTStrategyInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SegmentSolvLSTStrategyInstance { - /// 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( - &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 [`handleGatewayMessage`] function. - pub fn handleGatewayMessage( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - message: alloy::sol_types::private::Bytes, - ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { - self.call_builder( - &handleGatewayMessageCall { - tokenSent, - amountIn, - recipient, - message, - }, - ) - } - ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. - pub fn handleGatewayMessageWithSlippageArgs( - &self, - tokenSent: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - args: ::RustType, - ) -> alloy_contract::SolCallBuilder< - &P, - handleGatewayMessageWithSlippageArgsCall, - N, - > { - self.call_builder( - &handleGatewayMessageWithSlippageArgsCall { - tokenSent, - amount, - recipient, - args, - }, - ) - } - ///Creates a new call builder for the [`segmentStrategy`] function. - pub fn segmentStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, segmentStrategyCall, N> { - self.call_builder(&segmentStrategyCall) - } - ///Creates a new call builder for the [`solvLSTStrategy`] function. - pub fn solvLSTStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, solvLSTStrategyCall, N> { - self.call_builder(&solvLSTStrategyCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SegmentSolvLSTStrategyInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`TokenOutput`] event. - pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/segment_strategy.rs b/crates/bindings/src/segment_strategy.rs deleted file mode 100644 index b1f1b1157..000000000 --- a/crates/bindings/src/segment_strategy.rs +++ /dev/null @@ -1,1554 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface SegmentStrategy { - struct StrategySlippageArgs { - uint256 amountOutMin; - } - - event TokenOutput(address tokenReceived, uint256 amountOut); - - constructor(address _seBep20); - - function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; - function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; - function seBep20() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "_seBep20", - "type": "address", - "internalType": "contract ISeBep20" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessage", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "message", - "type": "bytes", - "internalType": "bytes" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessageWithSlippageArgs", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "args", - "type": "tuple", - "internalType": "struct StrategySlippageArgs", - "components": [ - { - "name": "amountOutMin", - "type": "uint256", - "internalType": "uint256" - } - ] - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "seBep20", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract ISeBep20" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "TokenOutput", - "inputs": [ - { - "name": "tokenReceived", - "type": "address", - "indexed": false, - "internalType": "address" - }, - { - "name": "amountOut", - "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 SegmentStrategy { - use super::*; - use alloy::sol_types as 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__\xFD[P`@Qa\x0C\xC68\x03\x80a\x0C\xC6\x839\x81\x01`@\x81\x90Ra\0.\x91a\0?V[`\x01`\x01`\xA0\x1B\x03\x16`\x80Ra\0lV[_` \x82\x84\x03\x12\x15a\0OW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0eW__\xFD[\x93\x92PPPV[`\x80Qa\x0C.a\0\x98_9_\x81\x81`H\x01R\x81\x81a\x01#\x01R\x81\x81a\x01\x8D\x01Ra\x02K\x01Ra\x0C._\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0?W_5`\xE0\x1C\x80c\x1B\xF7\xDF{\x14a\0CW\x80cPcL\x0E\x14a\0\x93W\x80c\x7F\x81O5\x14a\0\xA8W[__\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\t\xB4V[a\0\xBBV[\0[a\0\xA6a\0\xB66`\x04a\nvV[a\0\xE5V[_\x81\x80` \x01\x90Q\x81\x01\x90a\0\xD0\x91\x90a\n\xFAV[\x90Pa\0\xDE\x85\x85\x85\x84a\0\xE5V[PPPPPV[a\x01\x07s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xA5V[a\x01Hs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05iV[`@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\x83\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\x91_\x91\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xD6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xFA\x91\x90a\x0B\x1EV[`@Q\x7F#2>\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x88\x90R\x91\x92P_\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\x90c#2>\x03\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02\x91W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xB5\x91\x90a\x0B\x1EV[\x90P\x80\x15a\x03\nW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FCould not mint token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@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\x86\x81\x16`\x04\x83\x01R_\x91\x90\x85\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03wW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x9B\x91\x90a\x0B\x1EV[\x90P\x82\x81\x11a\x03\xECW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[_a\x03\xF7\x84\x83a\x0BbV[\x86Q\x90\x91P\x81\x10\x15a\x04KW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05c\x90\x85\x90\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\x90`\x84\x01[`@\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\x06dV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xDDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x01\x91\x90a\x0B\x1EV[a\x06\x0B\x91\x90a\x0B{V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05c\x90\x85\x90\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\x90`d\x01a\x04\xFFV[_a\x06\xC5\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\x07Z\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07UW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xE3\x91\x90a\x0B\x8EV[a\x07UW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[PPPV[``a\x07h\x84\x84_\x85a\x07rV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xEAW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08NW`@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\x03\x01V[__\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\x08v\x91\x90a\x0B\xADV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB0W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB5V[``\x91P[P\x91P\x91Pa\x08\xC5\x82\x82\x86a\x08\xD0V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xDFWP\x81a\x07kV[\x82Q\x15a\x08\xEFW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\x01\x91\x90a\x0B\xC3V[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\t*W__\xFD[PV[\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}Wa\t}a\t-V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xACWa\t\xACa\t-V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xC7W__\xFD[\x845a\t\xD2\x81a\t\tV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xE9\x81a\t\tV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x04W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x14W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n.Wa\n.a\t-V[a\nA` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x83V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nUW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x8AW__\xFD[\x855a\n\x95\x81a\t\tV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xAC\x81a\t\tV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xDDW__\xFD[Pa\n\xE6a\tZV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x0BW__\xFD[Pa\x0B\x14a\tZV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B.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`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x0BuWa\x0Bua\x0B5V[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0BuWa\x0Bua\x0B5V[_` \x82\x84\x03\x12\x15a\x0B\x9EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07kW__\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\xFE\xA2dipfsX\"\x12 \x96\xEFe\xB7\x9F\r\x80\x90U\x93\x15 \xD9\x88!\x13\xA9\xD5\xB6{=\xE4\xB8guk\xD84\x96\x11p%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\0?W_5`\xE0\x1C\x80c\x1B\xF7\xDF{\x14a\0CW\x80cPcL\x0E\x14a\0\x93W\x80c\x7F\x81O5\x14a\0\xA8W[__\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\t\xB4V[a\0\xBBV[\0[a\0\xA6a\0\xB66`\x04a\nvV[a\0\xE5V[_\x81\x80` \x01\x90Q\x81\x01\x90a\0\xD0\x91\x90a\n\xFAV[\x90Pa\0\xDE\x85\x85\x85\x84a\0\xE5V[PPPPPV[a\x01\x07s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xA5V[a\x01Hs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05iV[`@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\x83\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\x91_\x91\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xD6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xFA\x91\x90a\x0B\x1EV[`@Q\x7F#2>\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x88\x90R\x91\x92P_\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\x90c#2>\x03\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02\x91W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xB5\x91\x90a\x0B\x1EV[\x90P\x80\x15a\x03\nW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FCould not mint token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@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\x86\x81\x16`\x04\x83\x01R_\x91\x90\x85\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03wW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x9B\x91\x90a\x0B\x1EV[\x90P\x82\x81\x11a\x03\xECW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[_a\x03\xF7\x84\x83a\x0BbV[\x86Q\x90\x91P\x81\x10\x15a\x04KW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05c\x90\x85\x90\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\x90`\x84\x01[`@\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\x06dV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xDDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x01\x91\x90a\x0B\x1EV[a\x06\x0B\x91\x90a\x0B{V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05c\x90\x85\x90\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\x90`d\x01a\x04\xFFV[_a\x06\xC5\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\x07Z\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07UW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xE3\x91\x90a\x0B\x8EV[a\x07UW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[PPPV[``a\x07h\x84\x84_\x85a\x07rV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xEAW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08NW`@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\x03\x01V[__\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\x08v\x91\x90a\x0B\xADV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB0W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB5V[``\x91P[P\x91P\x91Pa\x08\xC5\x82\x82\x86a\x08\xD0V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xDFWP\x81a\x07kV[\x82Q\x15a\x08\xEFW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\x01\x91\x90a\x0B\xC3V[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\t*W__\xFD[PV[\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}Wa\t}a\t-V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xACWa\t\xACa\t-V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xC7W__\xFD[\x845a\t\xD2\x81a\t\tV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xE9\x81a\t\tV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x04W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x14W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n.Wa\n.a\t-V[a\nA` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x83V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nUW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x8AW__\xFD[\x855a\n\x95\x81a\t\tV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xAC\x81a\t\tV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xDDW__\xFD[Pa\n\xE6a\tZV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x0BW__\xFD[Pa\x0B\x14a\tZV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B.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`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x0BuWa\x0Bua\x0B5V[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0BuWa\x0Bua\x0B5V[_` \x82\x84\x03\x12\x15a\x0B\x9EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07kW__\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\xFE\xA2dipfsX\"\x12 \x96\xEFe\xB7\x9F\r\x80\x90U\x93\x15 \xD9\x88!\x13\xA9\xD5\xB6{=\xE4\xB8guk\xD84\x96\x11p%dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct StrategySlippageArgs { uint256 amountOutMin; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct StrategySlippageArgs { - #[allow(missing_docs)] - pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: StrategySlippageArgs) -> Self { - (value.amountOutMin,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for StrategySlippageArgs { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { amountOutMin: tuple.0 } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for StrategySlippageArgs { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for StrategySlippageArgs { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for StrategySlippageArgs { - const NAME: &'static str = "StrategySlippageArgs"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "StrategySlippageArgs(uint256 amountOutMin)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) - .0 - .to_vec() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for StrategySlippageArgs { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.amountOutMin, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.amountOutMin, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. -```solidity -event TokenOutput(address tokenReceived, uint256 amountOut); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct TokenOutput { - #[allow(missing_docs)] - pub tokenReceived: alloy::sol_types::private::Address, - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for TokenOutput { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - tokenReceived: data.0, - amountOut: data.1, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.tokenReceived, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountOut), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 TokenOutput { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&TokenOutput> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - /**Constructor`. -```solidity -constructor(address _seBep20); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct constructorCall { - #[allow(missing_docs)] - pub _seBep20: alloy::sol_types::private::Address, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value._seBep20,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _seBep20: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolConstructor for constructorCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._seBep20, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. -```solidity -function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub message: alloy::sol_types::private::Bytes, - } - ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ); - #[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, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.message) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - message: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageCall { - 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, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; - const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.message, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. -```solidity -function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub args: ::RustType, - } - ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::primitives::aliases::U256, - alloy::sol_types::private::Address, - ::RustType, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.args) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - args: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageWithSlippageArgsReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageWithSlippageArgsReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; - const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.args, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `seBep20()` and selector `0x1bf7df7b`. -```solidity -function seBep20() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct seBep20Call; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`seBep20()`](seBep20Call) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct seBep20Return { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: seBep20Call) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for seBep20Call { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: seBep20Return) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for seBep20Return { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for seBep20Call { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "seBep20()"; - const SELECTOR: [u8; 4] = [27u8, 247u8, 223u8, 123u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: seBep20Return = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: seBep20Return = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`SegmentStrategy`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum SegmentStrategyCalls { - #[allow(missing_docs)] - handleGatewayMessage(handleGatewayMessageCall), - #[allow(missing_docs)] - handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), - #[allow(missing_docs)] - seBep20(seBep20Call), - } - #[automatically_derived] - impl SegmentStrategyCalls { - /// 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]] = &[ - [27u8, 247u8, 223u8, 123u8], - [80u8, 99u8, 76u8, 14u8], - [127u8, 129u8, 79u8, 53u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for SegmentStrategyCalls { - const NAME: &'static str = "SegmentStrategyCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 3usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::handleGatewayMessage(_) => { - ::SELECTOR - } - Self::handleGatewayMessageWithSlippageArgs(_) => { - ::SELECTOR - } - Self::seBep20(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn seBep20( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(SegmentStrategyCalls::seBep20) - } - seBep20 - }, - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SegmentStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - SegmentStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn seBep20( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentStrategyCalls::seBep20) - } - seBep20 - }, - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - SegmentStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::handleGatewayMessage(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::seBep20(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::handleGatewayMessage(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::seBep20(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - ///Container for all the [`SegmentStrategy`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum SegmentStrategyEvents { - #[allow(missing_docs)] - TokenOutput(TokenOutput), - } - #[automatically_derived] - impl SegmentStrategyEvents { - /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for SegmentStrategyEvents { - const NAME: &'static str = "SegmentStrategyEvents"; - const COUNT: usize = 1usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::TokenOutput) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 SegmentStrategyEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`SegmentStrategy`](self) contract instance. - -See the [wrapper's documentation](`SegmentStrategyInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> SegmentStrategyInstance { - SegmentStrategyInstance::::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: alloy_contract::private::Network, - >( - provider: P, - _seBep20: alloy::sol_types::private::Address, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - SegmentStrategyInstance::::deploy(provider, _seBep20) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - _seBep20: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - SegmentStrategyInstance::::deploy_builder(provider, _seBep20) - } - /**A [`SegmentStrategy`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`SegmentStrategy`](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 SegmentStrategyInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for SegmentStrategyInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("SegmentStrategyInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SegmentStrategyInstance { - /**Creates a new wrapper around an on-chain [`SegmentStrategy`](self) contract instance. - -See the [wrapper's documentation](`SegmentStrategyInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - _seBep20: alloy::sol_types::private::Address, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder(provider, _seBep20); - 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, - _seBep20: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { _seBep20 }, - )[..], - ] - .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 SegmentStrategyInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> SegmentStrategyInstance { - SegmentStrategyInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SegmentStrategyInstance { - /// 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( - &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 [`handleGatewayMessage`] function. - pub fn handleGatewayMessage( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - message: alloy::sol_types::private::Bytes, - ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { - self.call_builder( - &handleGatewayMessageCall { - tokenSent, - amountIn, - recipient, - message, - }, - ) - } - ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. - pub fn handleGatewayMessageWithSlippageArgs( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - args: ::RustType, - ) -> alloy_contract::SolCallBuilder< - &P, - handleGatewayMessageWithSlippageArgsCall, - N, - > { - self.call_builder( - &handleGatewayMessageWithSlippageArgsCall { - tokenSent, - amountIn, - recipient, - args, - }, - ) - } - ///Creates a new call builder for the [`seBep20`] function. - pub fn seBep20(&self) -> alloy_contract::SolCallBuilder<&P, seBep20Call, N> { - self.call_builder(&seBep20Call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SegmentStrategyInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`TokenOutput`] event. - pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/segment_strategy_forked.rs b/crates/bindings/src/segment_strategy_forked.rs deleted file mode 100644 index 3ec912ab9..000000000 --- a/crates/bindings/src/segment_strategy_forked.rs +++ /dev/null @@ -1,7991 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface SegmentStrategyForked { - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function setUp() external; - function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function testSegmentStrategy() external; - function token() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "setUp", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "simulateForkAndTransfer", - "inputs": [ - { - "name": "forkAtBlock", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "sender", - "type": "address", - "internalType": "address" - }, - { - "name": "receiver", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testSegmentStrategy", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "token", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IERC20" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 SegmentStrategyForked { - use super::*; - use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15`+W__\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16t\xBB\xA2\xEF\x94]R^<#\x14a\x01=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05\xD0W__\xFD[PZ\xF1\x15\x80\x15a\x05\xE2W=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x06iW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x8D\x91\x90a\x18\x88V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07%W__\xFD[PZ\xF1\x15\x80\x15a\x077W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07\x94W__\xFD[PZ\xF1\x15\x80\x15a\x07\xA6W=__>=_\xFD[PP`@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\x81R`\x01`\x04\x82\x01R_\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x15W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x089\x91\x90a\x18\xAEV[\x90Pa\x08{\x81_`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01\x7FUser has seTokens\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x13\xB9V[`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\tO\x91a\x01\0\x90\x04s\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\x08\xEFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\x13\x91\x90a\x18\xAEV[_`@Q\x80`@\x01`@R\x80`\x17\x81R` \x01\x7FUser has no TBTC tokens\0\0\0\0\0\0\0\0\0\x81RPa\x14>V[`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t\xB2W__\xFD[PZ\xF1\x15\x80\x15a\t\xC4W=__>=_\xFD[PP`@Q\x7F\xDB\0ju\0\0\0\0\0\0\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\x90Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x16\x92Pc\xDB\0ju\x91P`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\n2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\nV\x91\x90a\x18\xAEV[P`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\x0B\x0E\x91a\x01\0\x90\x04s\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\n\xCBW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xEF\x91\x90a\x18\xAEV[_`@Q\x80``\x01`@R\x80`&\x81R` \x01a&\xB5`&\x919a\x13\xB9V[PPPV[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x0Bf\x90a\x187V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\x92\x90a\x187V[\x80\x15a\x0B\xDDW\x80`\x1F\x10a\x0B\xB4Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\xDDV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xC0W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x0CtW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C!W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0B6V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\x0C\xCC\x90a\x187V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C\xF8\x90a\x187V[\x80\x15a\rCW\x80`\x1F\x10a\r\x1AWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rCV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r&W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xAFV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0EBW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\xEFW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\rzV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0FEW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0E\xF2W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0E}V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\x0F\x9D\x90a\x187V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F\xC9\x90a\x187V[\x80\x15a\x10\x14W\x80`\x1F\x10a\x0F\xEBWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x10\x14V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\xF7W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0F\x80V[`\x08T_\x90`\xFF\x16\x15a\x10?WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\xCDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\xF1\x91\x90a\x18\xAEV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\xFEW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x12%\x91\x90\x81\x01\x90a\x18\xF2V[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x12C\x92\x91\x90a\x19\xA6V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x12_W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\x83\x91\x90a\x18\xAEV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12\xFCW__\xFD[PZ\xF1\x15\x80\x15a\x13\x0EW=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x13\x8EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13\xB2\x91\x90a\x18\x88V[PPPPPV[`@Q\x7F\xD9\xA3\xC4\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xD9\xA3\xC4\xD2\x90a\x14\r\x90\x86\x90\x86\x90\x86\x90`\x04\x01a\x19\xC7V[_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x14#W__\xFD[PZ\xFA\x15\x80\x15a\x145W=__>=_\xFD[PPPPPPPV[`@Q\x7F\x88\xB4L\x85\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x88\xB4L\x85\x90a\x14\r\x90\x86\x90\x86\x90\x86\x90`\x04\x01a\x19\xC7V[a\x0C\xC6\x80a\x19\xEF\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x14\xECW\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\x14\xB8V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x16\rW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x15\xF3W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x15\xDD\x84\x86Qa\x14\xF7V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x15\xA3V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x15KV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x16kW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x16+V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x16\rW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x16\xC1`@\x88\x01\x82a\x14\xF7V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x16\xDC\x81\x83a\x16\x19V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16\x9BV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x16\rW`?\x19\x87\x86\x03\x01\x84Ra\x175\x85\x83Qa\x14\xF7V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x17\x19V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x16\rW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x17\xB8`@\x87\x01\x82a\x16\x19V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x17pV[\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\xF1W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x18\tW__\xFD[\x845\x93Pa\x18\x19` \x86\x01a\x17\xCEV[\x92Pa\x18'`@\x86\x01a\x17\xCEV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x18KW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x18\x82W\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x18\x98W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x18\xA7W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x18\xBEW__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x19\x02W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x19\x18W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x19(W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x19BWa\x19Ba\x18\xC5V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x19rWa\x19ra\x18\xC5V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x19\x89W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x19\xB8`@\x83\x01\x85a\x14\xF7V[\x90P\x82` \x83\x01R\x93\x92PPPV[\x83\x81R\x82` \x82\x01R```@\x82\x01R_a\x19\xE5``\x83\x01\x84a\x14\xF7V[\x95\x94PPPPPV\xFE`\xA0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x0C\xC68\x03\x80a\x0C\xC6\x839\x81\x01`@\x81\x90Ra\0.\x91a\0?V[`\x01`\x01`\xA0\x1B\x03\x16`\x80Ra\0lV[_` \x82\x84\x03\x12\x15a\0OW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0eW__\xFD[\x93\x92PPPV[`\x80Qa\x0C.a\0\x98_9_\x81\x81`H\x01R\x81\x81a\x01#\x01R\x81\x81a\x01\x8D\x01Ra\x02K\x01Ra\x0C._\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0?W_5`\xE0\x1C\x80c\x1B\xF7\xDF{\x14a\0CW\x80cPcL\x0E\x14a\0\x93W\x80c\x7F\x81O5\x14a\0\xA8W[__\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\t\xB4V[a\0\xBBV[\0[a\0\xA6a\0\xB66`\x04a\nvV[a\0\xE5V[_\x81\x80` \x01\x90Q\x81\x01\x90a\0\xD0\x91\x90a\n\xFAV[\x90Pa\0\xDE\x85\x85\x85\x84a\0\xE5V[PPPPPV[a\x01\x07s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xA5V[a\x01Hs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05iV[`@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\x83\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\x91_\x91\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xD6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xFA\x91\x90a\x0B\x1EV[`@Q\x7F#2>\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x88\x90R\x91\x92P_\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\x90c#2>\x03\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02\x91W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xB5\x91\x90a\x0B\x1EV[\x90P\x80\x15a\x03\nW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FCould not mint token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@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\x86\x81\x16`\x04\x83\x01R_\x91\x90\x85\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03wW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x9B\x91\x90a\x0B\x1EV[\x90P\x82\x81\x11a\x03\xECW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[_a\x03\xF7\x84\x83a\x0BbV[\x86Q\x90\x91P\x81\x10\x15a\x04KW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05c\x90\x85\x90\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\x90`\x84\x01[`@\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\x06dV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xDDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x01\x91\x90a\x0B\x1EV[a\x06\x0B\x91\x90a\x0B{V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05c\x90\x85\x90\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\x90`d\x01a\x04\xFFV[_a\x06\xC5\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\x07Z\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07UW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xE3\x91\x90a\x0B\x8EV[a\x07UW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[PPPV[``a\x07h\x84\x84_\x85a\x07rV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xEAW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08NW`@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\x03\x01V[__\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\x08v\x91\x90a\x0B\xADV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB0W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB5V[``\x91P[P\x91P\x91Pa\x08\xC5\x82\x82\x86a\x08\xD0V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xDFWP\x81a\x07kV[\x82Q\x15a\x08\xEFW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\x01\x91\x90a\x0B\xC3V[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\t*W__\xFD[PV[\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}Wa\t}a\t-V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xACWa\t\xACa\t-V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xC7W__\xFD[\x845a\t\xD2\x81a\t\tV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xE9\x81a\t\tV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x04W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x14W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n.Wa\n.a\t-V[a\nA` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x83V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nUW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x8AW__\xFD[\x855a\n\x95\x81a\t\tV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xAC\x81a\t\tV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xDDW__\xFD[Pa\n\xE6a\tZV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x0BW__\xFD[Pa\x0B\x14a\tZV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B.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`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x0BuWa\x0Bua\x0B5V[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0BuWa\x0Bua\x0B5V[_` \x82\x84\x03\x12\x15a\x0B\x9EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07kW__\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\xFE\xA2dipfsX\"\x12 \x96\xEFe\xB7\x9F\r\x80\x90U\x93\x15 \xD9\x88!\x13\xA9\xD5\xB6{=\xE4\xB8guk\xD84\x96\x11p%dsolcC\0\x08\x1C\x003User received TBTC tokens after redeem\xA2dipfsX\"\x12 q\xD7\x80\xCD\x85WHNS\xD8Q_\x92\x85i\xF0>\x86\x0C\x0Ee2\xB4\xA9\xDEyK\x97\xF6\x8F\xD5\x86dsolcC\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\0\xFBW_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\x93W\x80c\xE2\x0C\x9Fq\x11a\0cW\x80c\xE2\x0C\x9Fq\x14a\x01\xBBW\x80c\xF9\xCE\x0EZ\x14a\x01\xC3W\x80c\xFAv&\xD4\x14a\x01\xD6W\x80c\xFC\x0CTj\x14a\x01\xE3W__\xFD[\x80c\x91j\x17\xC6\x14a\x01~W\x80c\xB0FO\xDC\x14a\x01\x93W\x80c\xB5P\x8A\xA9\x14a\x01\x9BW\x80c\xBAAO\xA6\x14a\x01\xA3W__\xFD[\x80c?r\x86\xF4\x11a\0\xCEW\x80c?r\x86\xF4\x14a\x01DW\x80cP\x05\xC7V\x14a\x01LW\x80cf\xD9\xA9\xA0\x14a\x01TW\x80c\x85\"l\x81\x14a\x01iW__\xFD[\x80c\n\x92T\xE4\x14a\0\xFFW\x80c\x1E\xD7\x83\x1C\x14a\x01\tW\x80c*\xDE8\x80\x14a\x01'W\x80c>^<#\x14a\x01=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x05\xD0W__\xFD[PZ\xF1\x15\x80\x15a\x05\xE2W=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x06iW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x8D\x91\x90a\x18\x88V[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07%W__\xFD[PZ\xF1\x15\x80\x15a\x077W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07\x94W__\xFD[PZ\xF1\x15\x80\x15a\x07\xA6W=__>=_\xFD[PP`@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\x81R`\x01`\x04\x82\x01R_\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x91Pcp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x15W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x089\x91\x90a\x18\xAEV[\x90Pa\x08{\x81_`@Q\x80`@\x01`@R\x80`\x11\x81R` \x01\x7FUser has seTokens\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81RPa\x13\xB9V[`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\tO\x91a\x01\0\x90\x04s\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\x08\xEFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\x13\x91\x90a\x18\xAEV[_`@Q\x80`@\x01`@R\x80`\x17\x81R` \x01\x7FUser has no TBTC tokens\0\0\0\0\0\0\0\0\0\x81RPa\x14>V[`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t\xB2W__\xFD[PZ\xF1\x15\x80\x15a\t\xC4W=__>=_\xFD[PP`@Q\x7F\xDB\0ju\0\0\0\0\0\0\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\x90Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x16\x92Pc\xDB\0ju\x91P`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\n2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\nV\x91\x90a\x18\xAEV[P`\x1FT`@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\x81R`\x01`\x04\x82\x01Ra\x0B\x0E\x91a\x01\0\x90\x04s\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\n\xCBW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\n\xEF\x91\x90a\x18\xAEV[_`@Q\x80``\x01`@R\x80`&\x81R` \x01a&\xB5`&\x919a\x13\xB9V[PPPV[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x0Bf\x90a\x187V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0B\x92\x90a\x187V[\x80\x15a\x0B\xDDW\x80`\x1F\x10a\x0B\xB4Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x0B\xDDV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0B\xC0W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x0CtW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C!W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0B6V[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\x0C\xCC\x90a\x187V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C\xF8\x90a\x187V[\x80\x15a\rCW\x80`\x1F\x10a\r\x1AWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rCV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r&W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xAFV[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0EBW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\r\xEFW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\rzV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0FEW` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0E\xF2W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0E}V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\x0F\x9D\x90a\x187V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0F\xC9\x90a\x187V[\x80\x15a\x10\x14W\x80`\x1F\x10a\x0F\xEBWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x10\x14V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0F\xF7W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0F\x80V[`\x08T_\x90`\xFF\x16\x15a\x10?WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x10\xCDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\xF1\x91\x90a\x18\xAEV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x11\xFEW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x12%\x91\x90\x81\x01\x90a\x18\xF2V[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x12C\x92\x91\x90a\x19\xA6V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x12_W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\x83\x91\x90a\x18\xAEV[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x12\xFCW__\xFD[PZ\xF1\x15\x80\x15a\x13\x0EW=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x13\x8EW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13\xB2\x91\x90a\x18\x88V[PPPPPV[`@Q\x7F\xD9\xA3\xC4\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\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xD9\xA3\xC4\xD2\x90a\x14\r\x90\x86\x90\x86\x90\x86\x90`\x04\x01a\x19\xC7V[_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x14#W__\xFD[PZ\xFA\x15\x80\x15a\x145W=__>=_\xFD[PPPPPPPV[`@Q\x7F\x88\xB4L\x85\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x88\xB4L\x85\x90a\x14\r\x90\x86\x90\x86\x90\x86\x90`\x04\x01a\x19\xC7V[a\x0C\xC6\x80a\x19\xEF\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x14\xECW\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\x14\xB8V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x16\rW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x15\xF3W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x15\xDD\x84\x86Qa\x14\xF7V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x15\xA3V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x15KV[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x16kW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x16+V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x16\rW`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x16\xC1`@\x88\x01\x82a\x14\xF7V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x16\xDC\x81\x83a\x16\x19V[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16\x9BV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x16\rW`?\x19\x87\x86\x03\x01\x84Ra\x175\x85\x83Qa\x14\xF7V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x17\x19V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x16\rW`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x17\xB8`@\x87\x01\x82a\x16\x19V[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x17pV[\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\xF1W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x18\tW__\xFD[\x845\x93Pa\x18\x19` \x86\x01a\x17\xCEV[\x92Pa\x18'`@\x86\x01a\x17\xCEV[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x18KW`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x18\x82W\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x18\x98W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x18\xA7W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x18\xBEW__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x19\x02W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x19\x18W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x19(W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x19BWa\x19Ba\x18\xC5V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x19rWa\x19ra\x18\xC5V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x19\x89W__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x19\xB8`@\x83\x01\x85a\x14\xF7V[\x90P\x82` \x83\x01R\x93\x92PPPV[\x83\x81R\x82` \x82\x01R```@\x82\x01R_a\x19\xE5``\x83\x01\x84a\x14\xF7V[\x95\x94PPPPPV\xFE`\xA0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x0C\xC68\x03\x80a\x0C\xC6\x839\x81\x01`@\x81\x90Ra\0.\x91a\0?V[`\x01`\x01`\xA0\x1B\x03\x16`\x80Ra\0lV[_` \x82\x84\x03\x12\x15a\0OW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0eW__\xFD[\x93\x92PPPV[`\x80Qa\x0C.a\0\x98_9_\x81\x81`H\x01R\x81\x81a\x01#\x01R\x81\x81a\x01\x8D\x01Ra\x02K\x01Ra\x0C._\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0?W_5`\xE0\x1C\x80c\x1B\xF7\xDF{\x14a\0CW\x80cPcL\x0E\x14a\0\x93W\x80c\x7F\x81O5\x14a\0\xA8W[__\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\t\xB4V[a\0\xBBV[\0[a\0\xA6a\0\xB66`\x04a\nvV[a\0\xE5V[_\x81\x80` \x01\x90Q\x81\x01\x90a\0\xD0\x91\x90a\n\xFAV[\x90Pa\0\xDE\x85\x85\x85\x84a\0\xE5V[PPPPPV[a\x01\x07s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x04\xA5V[a\x01Hs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x05iV[`@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\x83\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\x91_\x91\x83\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xD6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xFA\x91\x90a\x0B\x1EV[`@Q\x7F#2>\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x88\x90R\x91\x92P_\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\x90c#2>\x03\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02\x91W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xB5\x91\x90a\x0B\x1EV[\x90P\x80\x15a\x03\nW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FCould not mint token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@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\x86\x81\x16`\x04\x83\x01R_\x91\x90\x85\x16\x90cp\xA0\x821\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03wW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\x9B\x91\x90a\x0B\x1EV[\x90P\x82\x81\x11a\x03\xECW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FInsufficient supply provided\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[_a\x03\xF7\x84\x83a\x0BbV[\x86Q\x90\x91P\x81\x10\x15a\x04KW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x03\x01V[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x87\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x05c\x90\x85\x90\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\x90`\x84\x01[`@\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\x06dV[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xDDW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x01\x91\x90a\x0B\x1EV[a\x06\x0B\x91\x90a\x0B{V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x05c\x90\x85\x90\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\x90`d\x01a\x04\xFFV[_a\x06\xC5\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\x07Z\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07UW\x80\x80` \x01\x90Q\x81\x01\x90a\x06\xE3\x91\x90a\x0B\x8EV[a\x07UW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[PPPV[``a\x07h\x84\x84_\x85a\x07rV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\xEAW`@QbF\x1B\xCD`\xE5\x1B\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\x03\x01V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08NW`@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\x03\x01V[__\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\x08v\x91\x90a\x0B\xADV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\xB0W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\xB5V[``\x91P[P\x91P\x91Pa\x08\xC5\x82\x82\x86a\x08\xD0V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xDFWP\x81a\x07kV[\x82Q\x15a\x08\xEFW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x03\x01\x91\x90a\x0B\xC3V[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\t*W__\xFD[PV[\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}Wa\t}a\t-V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\xACWa\t\xACa\t-V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xC7W__\xFD[\x845a\t\xD2\x81a\t\tV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xE9\x81a\t\tV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x04W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\n\x14W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n.Wa\n.a\t-V[a\nA` `\x1F\x19`\x1F\x84\x01\x16\x01a\t\x83V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\nUW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\n\x8AW__\xFD[\x855a\n\x95\x81a\t\tV[\x94P` \x86\x015\x93P`@\x86\x015a\n\xAC\x81a\t\tV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xDDW__\xFD[Pa\n\xE6a\tZV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0B\x0BW__\xFD[Pa\x0B\x14a\tZV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B.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`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x0BuWa\x0Bua\x0B5V[\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\x0BuWa\x0Bua\x0B5V[_` \x82\x84\x03\x12\x15a\x0B\x9EW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07kW__\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\xFE\xA2dipfsX\"\x12 \x96\xEFe\xB7\x9F\r\x80\x90U\x93\x15 \xD9\x88!\x13\xA9\xD5\xB6{=\xE4\xB8guk\xD84\x96\x11p%dsolcC\0\x08\x1C\x003User received TBTC tokens after redeem\xA2dipfsX\"\x12 q\xD7\x80\xCD\x85WHNS\xD8Q_\x92\x85i\xF0>\x86\x0C\x0Ee2\xB4\xA9\xDEyK\x97\xF6\x8F\xD5\x86dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. -```solidity -event log(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `setUp()` and selector `0x0a9254e4`. -```solidity -function setUp() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setUpCall; - ///Container type for the return parameters of the [`setUp()`](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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl setUpReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for setUpCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = setUpReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "setUp()"; - const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - setUpReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. -```solidity -function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferCall { - #[allow(missing_docs)] - pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub sender: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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::Uint<256>, - ); - #[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::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferCall) -> Self { - (value.forkAtBlock, value.sender, value.receiver, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - forkAtBlock: tuple.0, - sender: tuple.1, - receiver: tuple.2, - amount: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl simulateForkAndTransferReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for simulateForkAndTransferCall { - type Parameters<'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::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = simulateForkAndTransferReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; - const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), - ::tokenize( - &self.sender, - ), - ::tokenize( - &self.receiver, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - simulateForkAndTransferReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testSegmentStrategy()` and selector `0x5005c756`. -```solidity -function testSegmentStrategy() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testSegmentStrategyCall; - ///Container type for the return parameters of the [`testSegmentStrategy()`](testSegmentStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testSegmentStrategyReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testSegmentStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testSegmentStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testSegmentStrategyReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testSegmentStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testSegmentStrategyReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testSegmentStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testSegmentStrategyReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testSegmentStrategy()"; - const SELECTOR: [u8; 4] = [80u8, 5u8, 199u8, 86u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testSegmentStrategyReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `token()` and selector `0xfc0c546a`. -```solidity -function token() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`token()`](tokenCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for tokenCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "token()"; - const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`SegmentStrategyForked`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum SegmentStrategyForkedCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - setUp(setUpCall), - #[allow(missing_docs)] - simulateForkAndTransfer(simulateForkAndTransferCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - testSegmentStrategy(testSegmentStrategyCall), - #[allow(missing_docs)] - token(tokenCall), - } - #[automatically_derived] - impl SegmentStrategyForkedCalls { - /// 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]] = &[ - [10u8, 146u8, 84u8, 228u8], - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [80u8, 5u8, 199u8, 86u8], - [102u8, 217u8, 169u8, 160u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [226u8, 12u8, 159u8, 113u8], - [249u8, 206u8, 14u8, 90u8], - [250u8, 118u8, 38u8, 212u8], - [252u8, 12u8, 84u8, 106u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for SegmentStrategyForkedCalls { - const NAME: &'static str = "SegmentStrategyForkedCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 16usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::setUp(_) => ::SELECTOR, - Self::simulateForkAndTransfer(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::testSegmentStrategy(_) => { - ::SELECTOR - } - Self::token(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(SegmentStrategyForkedCalls::setUp) - } - setUp - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SegmentStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SegmentStrategyForkedCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SegmentStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SegmentStrategyForkedCalls::targetContracts) - } - targetContracts - }, - { - fn testSegmentStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SegmentStrategyForkedCalls::testSegmentStrategy) - } - testSegmentStrategy - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SegmentStrategyForkedCalls::targetArtifactSelectors) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SegmentStrategyForkedCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SegmentStrategyForkedCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SegmentStrategyForkedCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SegmentStrategyForkedCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(SegmentStrategyForkedCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SegmentStrategyForkedCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SegmentStrategyForkedCalls::simulateForkAndTransfer) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(SegmentStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(SegmentStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentStrategyForkedCalls::setUp) - } - setUp - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentStrategyForkedCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentStrategyForkedCalls::targetContracts) - } - targetContracts - }, - { - fn testSegmentStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentStrategyForkedCalls::testSegmentStrategy) - } - testSegmentStrategy - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentStrategyForkedCalls::targetArtifactSelectors) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentStrategyForkedCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentStrategyForkedCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentStrategyForkedCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentStrategyForkedCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentStrategyForkedCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentStrategyForkedCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentStrategyForkedCalls::simulateForkAndTransfer) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SegmentStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::setUp(inner) => { - ::abi_encoded_size(inner) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testSegmentStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::token(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::setUp(inner) => { - ::abi_encode_raw(inner, out) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testSegmentStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::token(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - ///Container for all the [`SegmentStrategyForked`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum SegmentStrategyForkedEvents { - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl SegmentStrategyForkedEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for SegmentStrategyForkedEvents { - const NAME: &'static str = "SegmentStrategyForkedEvents"; - const COUNT: usize = 22usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 SegmentStrategyForkedEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`SegmentStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`SegmentStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> SegmentStrategyForkedInstance { - SegmentStrategyForkedInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - SegmentStrategyForkedInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - SegmentStrategyForkedInstance::::deploy_builder(provider) - } - /**A [`SegmentStrategyForked`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`SegmentStrategyForked`](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 SegmentStrategyForkedInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for SegmentStrategyForkedInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("SegmentStrategyForkedInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SegmentStrategyForkedInstance { - /**Creates a new wrapper around an on-chain [`SegmentStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`SegmentStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 SegmentStrategyForkedInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> SegmentStrategyForkedInstance { - SegmentStrategyForkedInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SegmentStrategyForkedInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`setUp`] function. - pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { - self.call_builder(&setUpCall) - } - ///Creates a new call builder for the [`simulateForkAndTransfer`] function. - pub fn simulateForkAndTransfer( - &self, - forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - sender: alloy::sol_types::private::Address, - receiver: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { - self.call_builder( - &simulateForkAndTransferCall { - forkAtBlock, - sender, - receiver, - amount, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`testSegmentStrategy`] function. - pub fn testSegmentStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testSegmentStrategyCall, N> { - self.call_builder(&testSegmentStrategyCall) - } - ///Creates a new call builder for the [`token`] function. - pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { - self.call_builder(&tokenCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SegmentStrategyForkedInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/shoebill_strategy.rs b/crates/bindings/src/shoebill_strategy.rs deleted file mode 100644 index 243d6b144..000000000 --- a/crates/bindings/src/shoebill_strategy.rs +++ /dev/null @@ -1,1554 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface ShoebillStrategy { - struct StrategySlippageArgs { - uint256 amountOutMin; - } - - event TokenOutput(address tokenReceived, uint256 amountOut); - - constructor(address _cErc20); - - function cErc20() external view returns (address); - function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; - function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "_cErc20", - "type": "address", - "internalType": "contract ICErc20" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "cErc20", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract ICErc20" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "handleGatewayMessage", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "message", - "type": "bytes", - "internalType": "bytes" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessageWithSlippageArgs", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "args", - "type": "tuple", - "internalType": "struct StrategySlippageArgs", - "components": [ - { - "name": "amountOutMin", - "type": "uint256", - "internalType": "uint256" - } - ] - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "event", - "name": "TokenOutput", - "inputs": [ - { - "name": "tokenReceived", - "type": "address", - "indexed": false, - "internalType": "address" - }, - { - "name": "amountOut", - "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 ShoebillStrategy { - use super::*; - use alloy::sol_types as 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__\xFD[P`@Qa\x0B\xF98\x03\x80a\x0B\xF9\x839\x81\x01`@\x81\x90R`+\x91`;V[`\x01`\x01`\xA0\x1B\x03\x16`\x80R`fV[_` \x82\x84\x03\x12\x15`JW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14`_W__\xFD[\x93\x92PPPV[`\x80Qa\x0Bna\0\x8B_9_\x81\x81`]\x01R\x81\x81a\x01#\x01Ra\x01w\x01Ra\x0Bn_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0?W_5`\xE0\x1C\x80cPcL\x0E\x14a\0CW\x80csBDG\x14a\0XW\x80c\x7F\x81O5\x14a\0\xA8W[__\xFD[a\0Va\0Q6`\x04a\t\x0FV[a\0\xBBV[\0[a\0\x7F\x7F\0\0\0\0\0\0\0\0\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\0Va\0\xB66`\x04a\t\xD1V[a\0\xE5V[_\x81\x80` \x01\x90Q\x81\x01\x90a\0\xD0\x91\x90a\nUV[\x90Pa\0\xDE\x85\x85\x85\x84a\0\xE5V[PPPPPV[a\x01\x07s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x03\xAAV[a\x01Hs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04nV[`@Q\x7F\xA0q-h\0\0\0\0\0\0\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\x7F\0\0\0\0\0\0\0\0\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_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x90c\xA0q-h\x90`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\xD6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xFA\x91\x90a\nyV[\x90P\x80\x15a\x02OW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FCould not mint token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@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\x02\xB9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xDD\x91\x90a\nyV[\x84Q\x90\x91P\x81\x10\x15a\x031W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02FV[a\x03Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x86\x83a\x05iV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04h\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xC4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04\xE2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x06\x91\x90a\nyV[a\x05\x10\x91\x90a\n\x90V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04h\x90\x85\x90\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\x90`d\x01a\x04\x04V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x05\xBF\x90\x84\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\x90`d\x01a\x04\x04V[PPPV[_a\x06%\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\x06\xB5\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x05\xBFW\x80\x80` \x01\x90Q\x81\x01\x90a\x06C\x91\x90a\n\xCEV[a\x05\xBFW`@QbF\x1B\xCD`\xE5\x1B\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\x02FV[``a\x06\xC3\x84\x84_\x85a\x06\xCDV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07EW`@QbF\x1B\xCD`\xE5\x1B\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\x02FV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x07\xA9W`@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\x02FV[__\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\x07\xD1\x91\x90a\n\xEDV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x0BW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x10V[``\x91P[P\x91P\x91Pa\x08 \x82\x82\x86a\x08+V[\x97\x96PPPPPPPV[``\x83\x15a\x08:WP\x81a\x06\xC6V[\x82Q\x15a\x08JW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x02F\x91\x90a\x0B\x03V[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\x08\x85W__\xFD[PV[\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\x08\xD8Wa\x08\xD8a\x08\x88V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\x07Wa\t\x07a\x08\x88V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\"W__\xFD[\x845a\t-\x81a\x08dV[\x93P` \x85\x015\x92P`@\x85\x015a\tD\x81a\x08dV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t_W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\toW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\x89Wa\t\x89a\x08\x88V[a\t\x9C` `\x1F\x19`\x1F\x84\x01\x16\x01a\x08\xDEV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\t\xB0W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\t\xE5W__\xFD[\x855a\t\xF0\x81a\x08dV[\x94P` \x86\x015\x93P`@\x86\x015a\n\x07\x81a\x08dV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n8W__\xFD[Pa\nAa\x08\xB5V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\nfW__\xFD[Pa\noa\x08\xB5V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\n\x89W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\n\xC8W\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[_` \x82\x84\x03\x12\x15a\n\xDEW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x06\xC6W__\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\xFE\xA2dipfsX\"\x12 \x11\xC0\xA5i\xF8\x0BGqCjz\x14\\T\xBC\x88\xC6\r\xF6\xCC\x19\\\x95\xB8\xDB\xC3\xCDP\xA5\xC2\x0E\x86dsolcC\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\0?W_5`\xE0\x1C\x80cPcL\x0E\x14a\0CW\x80csBDG\x14a\0XW\x80c\x7F\x81O5\x14a\0\xA8W[__\xFD[a\0Va\0Q6`\x04a\t\x0FV[a\0\xBBV[\0[a\0\x7F\x7F\0\0\0\0\0\0\0\0\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\0Va\0\xB66`\x04a\t\xD1V[a\0\xE5V[_\x81\x80` \x01\x90Q\x81\x01\x90a\0\xD0\x91\x90a\nUV[\x90Pa\0\xDE\x85\x85\x85\x84a\0\xE5V[PPPPPV[a\x01\x07s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x03\xAAV[a\x01Hs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04nV[`@Q\x7F\xA0q-h\0\0\0\0\0\0\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\x7F\0\0\0\0\0\0\0\0\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_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x90c\xA0q-h\x90`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\xD6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xFA\x91\x90a\nyV[\x90P\x80\x15a\x02OW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FCould not mint token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@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\x02\xB9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xDD\x91\x90a\nyV[\x84Q\x90\x91P\x81\x10\x15a\x031W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02FV[a\x03Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x86\x83a\x05iV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04h\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xC4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04\xE2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x06\x91\x90a\nyV[a\x05\x10\x91\x90a\n\x90V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04h\x90\x85\x90\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\x90`d\x01a\x04\x04V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x05\xBF\x90\x84\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\x90`d\x01a\x04\x04V[PPPV[_a\x06%\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\x06\xB5\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x05\xBFW\x80\x80` \x01\x90Q\x81\x01\x90a\x06C\x91\x90a\n\xCEV[a\x05\xBFW`@QbF\x1B\xCD`\xE5\x1B\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\x02FV[``a\x06\xC3\x84\x84_\x85a\x06\xCDV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07EW`@QbF\x1B\xCD`\xE5\x1B\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\x02FV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x07\xA9W`@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\x02FV[__\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\x07\xD1\x91\x90a\n\xEDV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x0BW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x10V[``\x91P[P\x91P\x91Pa\x08 \x82\x82\x86a\x08+V[\x97\x96PPPPPPPV[``\x83\x15a\x08:WP\x81a\x06\xC6V[\x82Q\x15a\x08JW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x02F\x91\x90a\x0B\x03V[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\x08\x85W__\xFD[PV[\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\x08\xD8Wa\x08\xD8a\x08\x88V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\x07Wa\t\x07a\x08\x88V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\"W__\xFD[\x845a\t-\x81a\x08dV[\x93P` \x85\x015\x92P`@\x85\x015a\tD\x81a\x08dV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t_W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\toW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\x89Wa\t\x89a\x08\x88V[a\t\x9C` `\x1F\x19`\x1F\x84\x01\x16\x01a\x08\xDEV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\t\xB0W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\t\xE5W__\xFD[\x855a\t\xF0\x81a\x08dV[\x94P` \x86\x015\x93P`@\x86\x015a\n\x07\x81a\x08dV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n8W__\xFD[Pa\nAa\x08\xB5V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\nfW__\xFD[Pa\noa\x08\xB5V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\n\x89W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\n\xC8W\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[_` \x82\x84\x03\x12\x15a\n\xDEW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x06\xC6W__\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\xFE\xA2dipfsX\"\x12 \x11\xC0\xA5i\xF8\x0BGqCjz\x14\\T\xBC\x88\xC6\r\xF6\xCC\x19\\\x95\xB8\xDB\xC3\xCDP\xA5\xC2\x0E\x86dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct StrategySlippageArgs { uint256 amountOutMin; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct StrategySlippageArgs { - #[allow(missing_docs)] - pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: StrategySlippageArgs) -> Self { - (value.amountOutMin,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for StrategySlippageArgs { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { amountOutMin: tuple.0 } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for StrategySlippageArgs { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for StrategySlippageArgs { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for StrategySlippageArgs { - const NAME: &'static str = "StrategySlippageArgs"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "StrategySlippageArgs(uint256 amountOutMin)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) - .0 - .to_vec() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for StrategySlippageArgs { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.amountOutMin, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.amountOutMin, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. -```solidity -event TokenOutput(address tokenReceived, uint256 amountOut); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct TokenOutput { - #[allow(missing_docs)] - pub tokenReceived: alloy::sol_types::private::Address, - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for TokenOutput { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - tokenReceived: data.0, - amountOut: data.1, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.tokenReceived, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountOut), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 TokenOutput { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&TokenOutput> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - /**Constructor`. -```solidity -constructor(address _cErc20); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct constructorCall { - #[allow(missing_docs)] - pub _cErc20: alloy::sol_types::private::Address, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value._cErc20,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _cErc20: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolConstructor for constructorCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._cErc20, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `cErc20()` and selector `0x73424447`. -```solidity -function cErc20() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct cErc20Call; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`cErc20()`](cErc20Call) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct cErc20Return { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: cErc20Call) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for cErc20Call { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: cErc20Return) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for cErc20Return { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for cErc20Call { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "cErc20()"; - const SELECTOR: [u8; 4] = [115u8, 66u8, 68u8, 71u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: cErc20Return = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: cErc20Return = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. -```solidity -function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub message: alloy::sol_types::private::Bytes, - } - ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ); - #[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, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.message) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - message: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageCall { - 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, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; - const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.message, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. -```solidity -function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub args: ::RustType, - } - ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::primitives::aliases::U256, - alloy::sol_types::private::Address, - ::RustType, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.args) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - args: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageWithSlippageArgsReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageWithSlippageArgsReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; - const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.args, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`ShoebillStrategy`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum ShoebillStrategyCalls { - #[allow(missing_docs)] - cErc20(cErc20Call), - #[allow(missing_docs)] - handleGatewayMessage(handleGatewayMessageCall), - #[allow(missing_docs)] - handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), - } - #[automatically_derived] - impl ShoebillStrategyCalls { - /// 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, 99u8, 76u8, 14u8], - [115u8, 66u8, 68u8, 71u8], - [127u8, 129u8, 79u8, 53u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for ShoebillStrategyCalls { - const NAME: &'static str = "ShoebillStrategyCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 3usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::cErc20(_) => ::SELECTOR, - Self::handleGatewayMessage(_) => { - ::SELECTOR - } - Self::handleGatewayMessageWithSlippageArgs(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ShoebillStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn cErc20( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ShoebillStrategyCalls::cErc20) - } - cErc20 - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - ShoebillStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ShoebillStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn cErc20( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ShoebillStrategyCalls::cErc20) - } - cErc20 - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - ShoebillStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::cErc20(inner) => { - ::abi_encoded_size(inner) - } - Self::handleGatewayMessage(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::cErc20(inner) => { - ::abi_encode_raw(inner, out) - } - Self::handleGatewayMessage(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`ShoebillStrategy`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum ShoebillStrategyEvents { - #[allow(missing_docs)] - TokenOutput(TokenOutput), - } - #[automatically_derived] - impl ShoebillStrategyEvents { - /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for ShoebillStrategyEvents { - const NAME: &'static str = "ShoebillStrategyEvents"; - const COUNT: usize = 1usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::TokenOutput) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 ShoebillStrategyEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`ShoebillStrategy`](self) contract instance. - -See the [wrapper's documentation](`ShoebillStrategyInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> ShoebillStrategyInstance { - ShoebillStrategyInstance::::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: alloy_contract::private::Network, - >( - provider: P, - _cErc20: alloy::sol_types::private::Address, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - ShoebillStrategyInstance::::deploy(provider, _cErc20) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - _cErc20: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - ShoebillStrategyInstance::::deploy_builder(provider, _cErc20) - } - /**A [`ShoebillStrategy`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`ShoebillStrategy`](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 ShoebillStrategyInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for ShoebillStrategyInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("ShoebillStrategyInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ShoebillStrategyInstance { - /**Creates a new wrapper around an on-chain [`ShoebillStrategy`](self) contract instance. - -See the [wrapper's documentation](`ShoebillStrategyInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - _cErc20: alloy::sol_types::private::Address, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder(provider, _cErc20); - 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, - _cErc20: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { _cErc20 }, - )[..], - ] - .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 ShoebillStrategyInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> ShoebillStrategyInstance { - ShoebillStrategyInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ShoebillStrategyInstance { - /// 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( - &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 [`cErc20`] function. - pub fn cErc20(&self) -> alloy_contract::SolCallBuilder<&P, cErc20Call, N> { - self.call_builder(&cErc20Call) - } - ///Creates a new call builder for the [`handleGatewayMessage`] function. - pub fn handleGatewayMessage( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - message: alloy::sol_types::private::Bytes, - ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { - self.call_builder( - &handleGatewayMessageCall { - tokenSent, - amountIn, - recipient, - message, - }, - ) - } - ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. - pub fn handleGatewayMessageWithSlippageArgs( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - args: ::RustType, - ) -> alloy_contract::SolCallBuilder< - &P, - handleGatewayMessageWithSlippageArgsCall, - N, - > { - self.call_builder( - &handleGatewayMessageWithSlippageArgsCall { - tokenSent, - amountIn, - recipient, - args, - }, - ) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ShoebillStrategyInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`TokenOutput`] event. - pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/shoebill_tbtc_strategy_forked.rs b/crates/bindings/src/shoebill_tbtc_strategy_forked.rs deleted file mode 100644 index 4b244234d..000000000 --- a/crates/bindings/src/shoebill_tbtc_strategy_forked.rs +++ /dev/null @@ -1,8006 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface ShoebillTBTCStrategyForked { - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function setUp() external; - function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function testShoebillStrategy() external; - function token() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "setUp", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "simulateForkAndTransfer", - "inputs": [ - { - "name": "forkAtBlock", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "sender", - "type": "address", - "internalType": "address" - }, - { - "name": "receiver", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testShoebillStrategy", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "token", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IERC20" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 ShoebillTBTCStrategyForked { - use super::*; - use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15`+W__\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16t\xBB\xA2\xEF\x94]R^<#\x14a\x01V[`@Qa\x01\x1E\x91\x90a\x14/V[a\x01\x07a\x08AV[a\x01~a\x0B\x95V[a\x01ia\x0C\x98V[a\x01\xABa\rcV[`@Q\x90\x15\x15\x81R` \x01a\x01\x1EV[a\x01\x11a\x0E3V[a\x01\x07a\x01\xD16`\x04a\x14\xDBV[a\x0E\x9EV[`\x1FTa\x01\xAB\x90`\xFF\x16\x81V[`\x1FTa\x02\x08\x90a\x01\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[`@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\x1EV[a\x02lbU\x8F\x18s\xA7\x9A5k\x01\xEF\x80[0\x89\xB4\xFEgD{\x96\xC7\xE6\xDDLs\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Eg\r\xE0\xB6\xB3\xA7d\0\0a\x0E\x9EV[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\x04W\x83\x82\x90_R` _ \x01\x80Ta\x03y\x90a\x15\x1CV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xA5\x90a\x15\x1CV[\x80\x15a\x03\xF0W\x80`\x1F\x10a\x03\xC7Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xF0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xD3W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03\\V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xFEV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6WPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x05M\x90a\x15\x1CV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05y\x90a\x15\x1CV[\x80\x15a\x05\xC4W\x80`\x1F\x10a\x05\x9BWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05\xC4V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05\xA7W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06[W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x06\x08W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05\x1DV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\x06\xB3\x90a\x15\x1CV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06\xDF\x90a\x15\x1CV[\x80\x15a\x07*W\x80`\x1F\x10a\x07\x01Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07*V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\rW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x06\x96V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x08)W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x07\xD6W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07aV[_s)%\xDF\x9E\xB2\t+S\xB0j\x065:rI\xAF:\x8B\x13\x9E\x90P_\x81`@Qa\x08g\x90a\x11wV[s\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_\xF0\x80\x15\x80\x15a\x08\x9DW=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t\x17W__\xFD[PZ\xF1\x15\x80\x15a\t)W=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\t\xB0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\xD4\x91\x90a\x15mV[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\nlW__\xFD[PZ\xF1\x15\x80\x15a\n~W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\n\xDBW__\xFD[PZ\xF1\x15\x80\x15a\n\xEDW=__>=_\xFD[PP`@Q\x7F:\xF9\xE6i\0\0\0\0\0\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`\x04\x82\x01Ra\x0B\x91\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x91Pc:\xF9\xE6i\x90`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0B_W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\x83\x91\x90a\x15\x93V[g\r\xE0\xB6\xB3\xA5\xD3e\xF2a\x10\xF4V[PPV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\x80W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C-W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0B\xB8V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\x0C\xD8\x90a\x15\x1CV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\x04\x90a\x15\x1CV[\x80\x15a\rOW\x80`\x1F\x10a\r&Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rOV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r2W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xBBV[`\x08T_\x90`\xFF\x16\x15a\rzWP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E,\x91\x90a\x15\x93V[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F9W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x0F`\x91\x90\x81\x01\x90a\x15\xD7V[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0F~\x92\x91\x90a\x16\x8BV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0F\x9AW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xBE\x91\x90a\x15\x93V[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x107W__\xFD[PZ\xF1\x15\x80\x15a\x10IW=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10\xC9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\xED\x91\x90a\x15mV[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x11]W__\xFD[PZ\xFA\x15\x80\x15a\x11oW=__>=_\xFD[PPPPPPV[a\x0B\xF9\x80a\x16\xAD\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x11\xD1W\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\x11\x9DV[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x12\xF2W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x12\xD8W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x12\xC2\x84\x86Qa\x11\xDCV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x12\x88V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x120V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x13PW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x13\x10V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x12\xF2W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x13\xA6`@\x88\x01\x82a\x11\xDCV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x13\xC1\x81\x83a\x12\xFEV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x13\x80V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x12\xF2W`?\x19\x87\x86\x03\x01\x84Ra\x14\x1A\x85\x83Qa\x11\xDCV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x13\xFEV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x12\xF2W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x14\x9D`@\x87\x01\x82a\x12\xFEV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14UV[\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\xD6W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x14\xEEW__\xFD[\x845\x93Pa\x14\xFE` \x86\x01a\x14\xB3V[\x92Pa\x15\x0C`@\x86\x01a\x14\xB3V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x150W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x15gW\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x15}W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x15\x8CW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x15\xA3W__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x15\xE7W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x15\xFDW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x16\rW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16'Wa\x16'a\x15\xAAV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x16WWa\x16Wa\x15\xAAV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x16nW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x16\x9D`@\x83\x01\x85a\x11\xDCV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xA0`@R4\x80\x15`\x0EW__\xFD[P`@Qa\x0B\xF98\x03\x80a\x0B\xF9\x839\x81\x01`@\x81\x90R`+\x91`;V[`\x01`\x01`\xA0\x1B\x03\x16`\x80R`fV[_` \x82\x84\x03\x12\x15`JW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14`_W__\xFD[\x93\x92PPPV[`\x80Qa\x0Bna\0\x8B_9_\x81\x81`]\x01R\x81\x81a\x01#\x01Ra\x01w\x01Ra\x0Bn_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0?W_5`\xE0\x1C\x80cPcL\x0E\x14a\0CW\x80csBDG\x14a\0XW\x80c\x7F\x81O5\x14a\0\xA8W[__\xFD[a\0Va\0Q6`\x04a\t\x0FV[a\0\xBBV[\0[a\0\x7F\x7F\0\0\0\0\0\0\0\0\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\0Va\0\xB66`\x04a\t\xD1V[a\0\xE5V[_\x81\x80` \x01\x90Q\x81\x01\x90a\0\xD0\x91\x90a\nUV[\x90Pa\0\xDE\x85\x85\x85\x84a\0\xE5V[PPPPPV[a\x01\x07s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x03\xAAV[a\x01Hs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04nV[`@Q\x7F\xA0q-h\0\0\0\0\0\0\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\x7F\0\0\0\0\0\0\0\0\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_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x90c\xA0q-h\x90`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\xD6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xFA\x91\x90a\nyV[\x90P\x80\x15a\x02OW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FCould not mint token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@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\x02\xB9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xDD\x91\x90a\nyV[\x84Q\x90\x91P\x81\x10\x15a\x031W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02FV[a\x03Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x86\x83a\x05iV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04h\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xC4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04\xE2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x06\x91\x90a\nyV[a\x05\x10\x91\x90a\n\x90V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04h\x90\x85\x90\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\x90`d\x01a\x04\x04V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x05\xBF\x90\x84\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\x90`d\x01a\x04\x04V[PPPV[_a\x06%\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\x06\xB5\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x05\xBFW\x80\x80` \x01\x90Q\x81\x01\x90a\x06C\x91\x90a\n\xCEV[a\x05\xBFW`@QbF\x1B\xCD`\xE5\x1B\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\x02FV[``a\x06\xC3\x84\x84_\x85a\x06\xCDV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07EW`@QbF\x1B\xCD`\xE5\x1B\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\x02FV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x07\xA9W`@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\x02FV[__\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\x07\xD1\x91\x90a\n\xEDV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x0BW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x10V[``\x91P[P\x91P\x91Pa\x08 \x82\x82\x86a\x08+V[\x97\x96PPPPPPPV[``\x83\x15a\x08:WP\x81a\x06\xC6V[\x82Q\x15a\x08JW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x02F\x91\x90a\x0B\x03V[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\x08\x85W__\xFD[PV[\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\x08\xD8Wa\x08\xD8a\x08\x88V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\x07Wa\t\x07a\x08\x88V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\"W__\xFD[\x845a\t-\x81a\x08dV[\x93P` \x85\x015\x92P`@\x85\x015a\tD\x81a\x08dV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t_W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\toW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\x89Wa\t\x89a\x08\x88V[a\t\x9C` `\x1F\x19`\x1F\x84\x01\x16\x01a\x08\xDEV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\t\xB0W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\t\xE5W__\xFD[\x855a\t\xF0\x81a\x08dV[\x94P` \x86\x015\x93P`@\x86\x015a\n\x07\x81a\x08dV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n8W__\xFD[Pa\nAa\x08\xB5V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\nfW__\xFD[Pa\noa\x08\xB5V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\n\x89W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\n\xC8W\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[_` \x82\x84\x03\x12\x15a\n\xDEW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x06\xC6W__\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\xFE\xA2dipfsX\"\x12 \x11\xC0\xA5i\xF8\x0BGqCjz\x14\\T\xBC\x88\xC6\r\xF6\xCC\x19\\\x95\xB8\xDB\xC3\xCDP\xA5\xC2\x0E\x86dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 \x13 s\xC9\xD6\x90\x10\xEC\xF0\xF9\xD1\xE2\xC7^<#\x14a\x01V[`@Qa\x01\x1E\x91\x90a\x14/V[a\x01\x07a\x08AV[a\x01~a\x0B\x95V[a\x01ia\x0C\x98V[a\x01\xABa\rcV[`@Q\x90\x15\x15\x81R` \x01a\x01\x1EV[a\x01\x11a\x0E3V[a\x01\x07a\x01\xD16`\x04a\x14\xDBV[a\x0E\x9EV[`\x1FTa\x01\xAB\x90`\xFF\x16\x81V[`\x1FTa\x02\x08\x90a\x01\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[`@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\x1EV[a\x02lbU\x8F\x18s\xA7\x9A5k\x01\xEF\x80[0\x89\xB4\xFEgD{\x96\xC7\xE6\xDDLs\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Eg\r\xE0\xB6\xB3\xA7d\0\0a\x0E\x9EV[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90[\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6W[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x04\x04W\x83\x82\x90_R` _ \x01\x80Ta\x03y\x90a\x15\x1CV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\xA5\x90a\x15\x1CV[\x80\x15a\x03\xF0W\x80`\x1F\x10a\x03\xC7Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xF0V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xD3W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03\\V[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xFEV[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6WPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6WPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x05M\x90a\x15\x1CV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05y\x90a\x15\x1CV[\x80\x15a\x05\xC4W\x80`\x1F\x10a\x05\x9BWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05\xC4V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05\xA7W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06[W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x06\x08W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x05\x1DV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\x06\xB3\x90a\x15\x1CV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x06\xDF\x90a\x15\x1CV[\x80\x15a\x07*W\x80`\x1F\x10a\x07\x01Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x07*V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x07\rW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x06\x96V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x08)W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x07\xD6W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x07aV[_s)%\xDF\x9E\xB2\t+S\xB0j\x065:rI\xAF:\x8B\x13\x9E\x90P_\x81`@Qa\x08g\x90a\x11wV[s\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_\xF0\x80\x15\x80\x15a\x08\x9DW=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\t\x17W__\xFD[PZ\xF1\x15\x80\x15a\t)W=__>=_\xFD[PP`\x1FT`@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\x85\x81\x16`\x04\x83\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\t\xB0W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\xD4\x91\x90a\x15mV[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x81\x16`\x04\x84\x01Rg\r\xE0\xB6\xB3\xA7d\0\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\nlW__\xFD[PZ\xF1\x15\x80\x15a\n~W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\n\xDBW__\xFD[PZ\xF1\x15\x80\x15a\n\xEDW=__>=_\xFD[PP`@Q\x7F:\xF9\xE6i\0\0\0\0\0\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`\x04\x82\x01Ra\x0B\x91\x92Ps\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x91Pc:\xF9\xE6i\x90`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0B_W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0B\x83\x91\x90a\x15\x93V[g\r\xE0\xB6\xB3\xA5\xD3e\xF2a\x10\xF4V[PPV[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C\x80W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0C-W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0B\xB8V[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x1BW\x83\x82\x90_R` _ \x01\x80Ta\x0C\xD8\x90a\x15\x1CV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\r\x04\x90a\x15\x1CV[\x80\x15a\rOW\x80`\x1F\x10a\r&Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\rOV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\r2W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0C\xBBV[`\x08T_\x90`\xFF\x16\x15a\rzWP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0E\x08W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E,\x91\x90a\x15\x93V[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xD1W` \x02\x82\x01\x91\x90_R` _ \x90\x81Ts\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xA6WPPPPP\x90P\x90V[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x0F9W=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x0F`\x91\x90\x81\x01\x90a\x15\xD7V[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x0F~\x92\x91\x90a\x16\x8BV[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x0F\x9AW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F\xBE\x91\x90a\x15\x93V[P`@Q\x7F\xCAf\x9F\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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x107W__\xFD[PZ\xF1\x15\x80\x15a\x10IW=__>=_\xFD[PP`\x1FT`@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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10\xC9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10\xED\x91\x90a\x15mV[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x11]W__\xFD[PZ\xFA\x15\x80\x15a\x11oW=__>=_\xFD[PPPPPPV[a\x0B\xF9\x80a\x16\xAD\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x11\xD1W\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\x11\x9DV[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x12\xF2W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x12\xD8W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x12\xC2\x84\x86Qa\x11\xDCV[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x12\x88V[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x120V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x13PW\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x13\x10V[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x12\xF2W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x13\xA6`@\x88\x01\x82a\x11\xDCV[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x13\xC1\x81\x83a\x12\xFEV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x13\x80V[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x12\xF2W`?\x19\x87\x86\x03\x01\x84Ra\x14\x1A\x85\x83Qa\x11\xDCV[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x13\xFEV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x12\xF2W`?\x19\x87\x86\x03\x01\x84R\x81Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x14\x9D`@\x87\x01\x82a\x12\xFEV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x14UV[\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\xD6W__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x14\xEEW__\xFD[\x845\x93Pa\x14\xFE` \x86\x01a\x14\xB3V[\x92Pa\x15\x0C`@\x86\x01a\x14\xB3V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x150W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x15gW\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[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x15}W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x15\x8CW__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x15\xA3W__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x15\xE7W__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x15\xFDW__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x16\rW__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x16'Wa\x16'a\x15\xAAV[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x16WWa\x16Wa\x15\xAAV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x16nW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x16\x9D`@\x83\x01\x85a\x11\xDCV[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xA0`@R4\x80\x15`\x0EW__\xFD[P`@Qa\x0B\xF98\x03\x80a\x0B\xF9\x839\x81\x01`@\x81\x90R`+\x91`;V[`\x01`\x01`\xA0\x1B\x03\x16`\x80R`fV[_` \x82\x84\x03\x12\x15`JW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14`_W__\xFD[\x93\x92PPPV[`\x80Qa\x0Bna\0\x8B_9_\x81\x81`]\x01R\x81\x81a\x01#\x01Ra\x01w\x01Ra\x0Bn_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0?W_5`\xE0\x1C\x80cPcL\x0E\x14a\0CW\x80csBDG\x14a\0XW\x80c\x7F\x81O5\x14a\0\xA8W[__\xFD[a\0Va\0Q6`\x04a\t\x0FV[a\0\xBBV[\0[a\0\x7F\x7F\0\0\0\0\0\0\0\0\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\0Va\0\xB66`\x04a\t\xD1V[a\0\xE5V[_\x81\x80` \x01\x90Q\x81\x01\x90a\0\xD0\x91\x90a\nUV[\x90Pa\0\xDE\x85\x85\x85\x84a\0\xE5V[PPPPPV[a\x01\x07s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x03\xAAV[a\x01Hs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04nV[`@Q\x7F\xA0q-h\0\0\0\0\0\0\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\x7F\0\0\0\0\0\0\0\0\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_\x90s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16\x90c\xA0q-h\x90`$\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\xD6W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xFA\x91\x90a\nyV[\x90P\x80\x15a\x02OW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x14`$\x82\x01R\x7FCould not mint token\0\0\0\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[`@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\x02\xB9W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xDD\x91\x90a\nyV[\x84Q\x90\x91P\x81\x10\x15a\x031W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02FV[a\x03Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x84\x16\x86\x83a\x05iV[`@\x80Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04h\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xC4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04\xE2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05\x06\x91\x90a\nyV[a\x05\x10\x91\x90a\n\x90V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04h\x90\x85\x90\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\x90`d\x01a\x04\x04V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x05\xBF\x90\x84\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\x90`d\x01a\x04\x04V[PPPV[_a\x06%\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\x06\xB5\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x05\xBFW\x80\x80` \x01\x90Q\x81\x01\x90a\x06C\x91\x90a\n\xCEV[a\x05\xBFW`@QbF\x1B\xCD`\xE5\x1B\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\x02FV[``a\x06\xC3\x84\x84_\x85a\x06\xCDV[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07EW`@QbF\x1B\xCD`\xE5\x1B\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\x02FV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x07\xA9W`@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\x02FV[__\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\x07\xD1\x91\x90a\n\xEDV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08\x0BW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08\x10V[``\x91P[P\x91P\x91Pa\x08 \x82\x82\x86a\x08+V[\x97\x96PPPPPPPV[``\x83\x15a\x08:WP\x81a\x06\xC6V[\x82Q\x15a\x08JW\x82Q\x80\x84` \x01\xFD[\x81`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\x02F\x91\x90a\x0B\x03V[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\x08\x85W__\xFD[PV[\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\x08\xD8Wa\x08\xD8a\x08\x88V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\x07Wa\t\x07a\x08\x88V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\"W__\xFD[\x845a\t-\x81a\x08dV[\x93P` \x85\x015\x92P`@\x85\x015a\tD\x81a\x08dV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t_W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\toW__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\x89Wa\t\x89a\x08\x88V[a\t\x9C` `\x1F\x19`\x1F\x84\x01\x16\x01a\x08\xDEV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\t\xB0W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\t\xE5W__\xFD[\x855a\t\xF0\x81a\x08dV[\x94P` \x86\x015\x93P`@\x86\x015a\n\x07\x81a\x08dV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n8W__\xFD[Pa\nAa\x08\xB5V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\nfW__\xFD[Pa\noa\x08\xB5V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\n\x89W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\n\xC8W\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[_` \x82\x84\x03\x12\x15a\n\xDEW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x06\xC6W__\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\xFE\xA2dipfsX\"\x12 \x11\xC0\xA5i\xF8\x0BGqCjz\x14\\T\xBC\x88\xC6\r\xF6\xCC\x19\\\x95\xB8\xDB\xC3\xCDP\xA5\xC2\x0E\x86dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 \x13 s\xC9\xD6\x90\x10\xEC\xF0\xF9\xD1\xE2\xC7 = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `setUp()` and selector `0x0a9254e4`. -```solidity -function setUp() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setUpCall; - ///Container type for the return parameters of the [`setUp()`](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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl setUpReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for setUpCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = setUpReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "setUp()"; - const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - setUpReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. -```solidity -function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferCall { - #[allow(missing_docs)] - pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub sender: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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::Uint<256>, - ); - #[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::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferCall) -> Self { - (value.forkAtBlock, value.sender, value.receiver, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - forkAtBlock: tuple.0, - sender: tuple.1, - receiver: tuple.2, - amount: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl simulateForkAndTransferReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for simulateForkAndTransferCall { - type Parameters<'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::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = simulateForkAndTransferReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; - const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), - ::tokenize( - &self.sender, - ), - ::tokenize( - &self.receiver, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - simulateForkAndTransferReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testShoebillStrategy()` and selector `0x95419e06`. -```solidity -function testShoebillStrategy() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testShoebillStrategyCall; - ///Container type for the return parameters of the [`testShoebillStrategy()`](testShoebillStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testShoebillStrategyReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testShoebillStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testShoebillStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testShoebillStrategyReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testShoebillStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testShoebillStrategyReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testShoebillStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testShoebillStrategyReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testShoebillStrategy()"; - const SELECTOR: [u8; 4] = [149u8, 65u8, 158u8, 6u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testShoebillStrategyReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `token()` and selector `0xfc0c546a`. -```solidity -function token() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`token()`](tokenCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for tokenCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "token()"; - const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`ShoebillTBTCStrategyForked`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum ShoebillTBTCStrategyForkedCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - setUp(setUpCall), - #[allow(missing_docs)] - simulateForkAndTransfer(simulateForkAndTransferCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - testShoebillStrategy(testShoebillStrategyCall), - #[allow(missing_docs)] - token(tokenCall), - } - #[automatically_derived] - impl ShoebillTBTCStrategyForkedCalls { - /// 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]] = &[ - [10u8, 146u8, 84u8, 228u8], - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [102u8, 217u8, 169u8, 160u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [149u8, 65u8, 158u8, 6u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [226u8, 12u8, 159u8, 113u8], - [249u8, 206u8, 14u8, 90u8], - [250u8, 118u8, 38u8, 212u8], - [252u8, 12u8, 84u8, 106u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for ShoebillTBTCStrategyForkedCalls { - const NAME: &'static str = "ShoebillTBTCStrategyForkedCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 16usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::setUp(_) => ::SELECTOR, - Self::simulateForkAndTransfer(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::testShoebillStrategy(_) => { - ::SELECTOR - } - Self::token(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ShoebillTBTCStrategyForkedCalls::setUp) - } - setUp - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::targetContracts) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - ShoebillTBTCStrategyForkedCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::targetSelectors) - } - targetSelectors - }, - { - fn testShoebillStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::testShoebillStrategy) - } - testShoebillStrategy - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ShoebillTBTCStrategyForkedCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - ShoebillTBTCStrategyForkedCalls::simulateForkAndTransfer, - ) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ShoebillTBTCStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(ShoebillTBTCStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::setUp) - } - setUp - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::targetContracts) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - ShoebillTBTCStrategyForkedCalls::targetArtifactSelectors, - ) - } - targetArtifactSelectors - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::targetSelectors) - } - targetSelectors - }, - { - fn testShoebillStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::testShoebillStrategy) - } - testShoebillStrategy - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::excludeContracts) - } - excludeContracts - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - ShoebillTBTCStrategyForkedCalls::simulateForkAndTransfer, - ) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(ShoebillTBTCStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::setUp(inner) => { - ::abi_encoded_size(inner) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testShoebillStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::token(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::setUp(inner) => { - ::abi_encode_raw(inner, out) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testShoebillStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::token(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - ///Container for all the [`ShoebillTBTCStrategyForked`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum ShoebillTBTCStrategyForkedEvents { - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl ShoebillTBTCStrategyForkedEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for ShoebillTBTCStrategyForkedEvents { - const NAME: &'static str = "ShoebillTBTCStrategyForkedEvents"; - const COUNT: usize = 22usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 ShoebillTBTCStrategyForkedEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`ShoebillTBTCStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`ShoebillTBTCStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> ShoebillTBTCStrategyForkedInstance { - ShoebillTBTCStrategyForkedInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - ShoebillTBTCStrategyForkedInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - ShoebillTBTCStrategyForkedInstance::::deploy_builder(provider) - } - /**A [`ShoebillTBTCStrategyForked`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`ShoebillTBTCStrategyForked`](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 ShoebillTBTCStrategyForkedInstance< - P, - N = alloy_contract::private::Ethereum, - > { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for ShoebillTBTCStrategyForkedInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("ShoebillTBTCStrategyForkedInstance") - .field(&self.address) - .finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ShoebillTBTCStrategyForkedInstance { - /**Creates a new wrapper around an on-chain [`ShoebillTBTCStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`ShoebillTBTCStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 ShoebillTBTCStrategyForkedInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> ShoebillTBTCStrategyForkedInstance { - ShoebillTBTCStrategyForkedInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ShoebillTBTCStrategyForkedInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`setUp`] function. - pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { - self.call_builder(&setUpCall) - } - ///Creates a new call builder for the [`simulateForkAndTransfer`] function. - pub fn simulateForkAndTransfer( - &self, - forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - sender: alloy::sol_types::private::Address, - receiver: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { - self.call_builder( - &simulateForkAndTransferCall { - forkAtBlock, - sender, - receiver, - amount, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`testShoebillStrategy`] function. - pub fn testShoebillStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testShoebillStrategyCall, N> { - self.call_builder(&testShoebillStrategyCall) - } - ///Creates a new call builder for the [`token`] function. - pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { - self.call_builder(&tokenCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ShoebillTBTCStrategyForkedInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/solv_btc_strategy.rs b/crates/bindings/src/solv_btc_strategy.rs deleted file mode 100644 index 0a3171835..000000000 --- a/crates/bindings/src/solv_btc_strategy.rs +++ /dev/null @@ -1,2006 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface SolvBTCStrategy { - struct StrategySlippageArgs { - uint256 amountOutMin; - } - - event TokenOutput(address tokenReceived, uint256 amountOut); - - constructor(address _solvBTCRouter, bytes32 _poolId, address _solvBTC); - - function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; - function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; - function poolId() external view returns (bytes32); - function solvBTC() external view returns (address); - function solvBTCRouter() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "_solvBTCRouter", - "type": "address", - "internalType": "contract ISolvBTCRouter" - }, - { - "name": "_poolId", - "type": "bytes32", - "internalType": "bytes32" - }, - { - "name": "_solvBTC", - "type": "address", - "internalType": "contract IERC20" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessage", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "message", - "type": "bytes", - "internalType": "bytes" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessageWithSlippageArgs", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "args", - "type": "tuple", - "internalType": "struct StrategySlippageArgs", - "components": [ - { - "name": "amountOutMin", - "type": "uint256", - "internalType": "uint256" - } - ] - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "poolId", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bytes32", - "internalType": "bytes32" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "solvBTC", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IERC20" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "solvBTCRouter", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract ISolvBTCRouter" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "TokenOutput", - "inputs": [ - { - "name": "tokenReceived", - "type": "address", - "indexed": false, - "internalType": "address" - }, - { - "name": "amountOut", - "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 SolvBTCStrategy { - use super::*; - use alloy::sol_types as 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\x15a\0\x0FW__\xFD[P`@Qa\x0C\xE38\x03\x80a\x0C\xE3\x839\x81\x01`@\x81\x90Ra\0.\x91a\0bV[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16`\x80R`\xA0\x91\x90\x91R\x16`\xC0Ra\0\xA2V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0_W__\xFD[PV[___``\x84\x86\x03\x12\x15a\0tW__\xFD[\x83Qa\0\x7F\x81a\0KV[` \x85\x01Q`@\x86\x01Q\x91\x94P\x92Pa\0\x97\x81a\0KV[\x80\x91PP\x92P\x92P\x92V[`\x80Q`\xA0Q`\xC0Qa\x0B\xF6a\0\xED_9_\x81\x81a\x01\x1B\x01R\x81\x81a\x03-\x01Ra\x03o\x01R_\x81\x81`\xBE\x01Ra\x01\xF2\x01R_\x81\x81`m\x01R\x81\x81a\x01\xA5\x01Ra\x02!\x01Ra\x0B\xF6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0dW_5`\xE0\x1C\x80cPcL\x0E\x11a\0MW\x80cPcL\x0E\x14a\0\xEEW\x80c\x7F\x81O5\x14a\x01\x03W\x80c\xB9\x93|\xCB\x14a\x01\x16W__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0hW\x80c>\r\xC3N\x14a\0\xB9W[__\xFD[a\0\x8F\x7F\0\0\0\0\0\0\0\0\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\xE0\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xB0V[a\x01\x01a\0\xFC6`\x04a\t\x97V[a\x01=V[\0[a\x01\x01a\x01\x116`\x04a\nYV[a\x01gV[a\0\x8F\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01R\x91\x90a\n\xDDV[\x90Pa\x01`\x85\x85\x85\x84a\x01gV[PPPPPV[a\x01\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x03\xCAV[a\x01\xCAs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\x8EV[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02|W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xA0\x91\x90a\x0B\x01V[\x82Q\x90\x91P\x81\x10\x15a\x03\x13W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03Ts\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\x84\x83a\x05\x89V[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\x88\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xE4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x02W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05&\x91\x90a\x0B\x01V[a\x050\x91\x90a\x0B\x18V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\x88\x90\x85\x90\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\x90`d\x01a\x04$V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x05\xDF\x90\x84\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\x90`d\x01a\x04$V[PPPV[_a\x06E\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\x06\xEF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x05\xDFW\x80\x80` \x01\x90Q\x81\x01\x90a\x06c\x91\x90a\x0BVV[a\x05\xDFW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[``a\x06\xFD\x84\x84_\x85a\x07\x07V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\x99W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\x17W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[__\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\x08?\x91\x90a\x0BuV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08yW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08~V[``\x91P[P\x91P\x91Pa\x08\x8E\x82\x82\x86a\x08\x99V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xA8WP\x81a\x07\0V[\x82Q\x15a\x08\xB8W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\n\x91\x90a\x0B\x8BV[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\t\rW__\xFD[PV[\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`Wa\t`a\t\x10V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\x8FWa\t\x8Fa\t\x10V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xAAW__\xFD[\x845a\t\xB5\x81a\x08\xECV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xCC\x81a\x08\xECV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xE7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\t\xF7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x11Wa\n\x11a\t\x10V[a\n$` `\x1F\x19`\x1F\x84\x01\x16\x01a\tfV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n8W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\nmW__\xFD[\x855a\nx\x81a\x08\xECV[\x94P` \x86\x015\x93P`@\x86\x015a\n\x8F\x81a\x08\xECV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xC0W__\xFD[Pa\n\xC9a\t=V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\n\xEEW__\xFD[Pa\n\xF7a\t=V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\x11W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0BPW\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[_` \x82\x84\x03\x12\x15a\x0BfW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\0W__\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\xFE\xA2dipfsX\"\x12 \xEA:\x8D\x8D\x03\xA7\x99\xDE\xBEZ\xF3\x80t\xA1\xC6S\x89f\xE8#\xECG\xA2\xDDfH\x1F<\x94\xF2SxdsolcC\0\x08\x1C\x003", - ); - /// The runtime bytecode of the contract, as deployed on the network. - /// - /// ```text - ///0x608060405234801561000f575f5ffd5b5060043610610064575f3560e01c806350634c0e1161004d57806350634c0e146100ee5780637f814f3514610103578063b9937ccb14610116575f5ffd5b806306af019a146100685780633e0dc34e146100b9575b5f5ffd5b61008f7f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020015b60405180910390f35b6100e07f000000000000000000000000000000000000000000000000000000000000000081565b6040519081526020016100b0565b6101016100fc366004610997565b61013d565b005b610101610111366004610a59565b610167565b61008f7f000000000000000000000000000000000000000000000000000000000000000081565b5f818060200190518101906101529190610add565b905061016085858584610167565b5050505050565b61018973ffffffffffffffffffffffffffffffffffffffff85163330866103ca565b6101ca73ffffffffffffffffffffffffffffffffffffffff85167f00000000000000000000000000000000000000000000000000000000000000008561048e565b6040517f6d724ead0000000000000000000000000000000000000000000000000000000081527f00000000000000000000000000000000000000000000000000000000000000006004820152602481018490525f907f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1690636d724ead906044016020604051808303815f875af115801561027c573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906102a09190610b01565b8251909150811015610313576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601a60248201527f496e73756666696369656e74206f757470757420616d6f756e7400000000000060448201526064015b60405180910390fd5b61035473ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000168483610589565b6040805173ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000168152602081018390527f0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d910160405180910390a15050505050565b60405173ffffffffffffffffffffffffffffffffffffffff808516602483015283166044820152606481018290526104889085907f23b872dd00000000000000000000000000000000000000000000000000000000906084015b60408051601f198184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff00000000000000000000000000000000000000000000000000000000909316929092179091526105e4565b50505050565b6040517fdd62ed3e00000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff83811660248301525f91839186169063dd62ed3e90604401602060405180830381865afa158015610502573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906105269190610b01565b6105309190610b18565b60405173ffffffffffffffffffffffffffffffffffffffff85166024820152604481018290529091506104889085907f095ea7b30000000000000000000000000000000000000000000000000000000090606401610424565b60405173ffffffffffffffffffffffffffffffffffffffff83166024820152604481018290526105df9084907fa9059cbb0000000000000000000000000000000000000000000000000000000090606401610424565b505050565b5f610645826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166106ef9092919063ffffffff16565b8051909150156105df57808060200190518101906106639190610b56565b6105df576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f74207375636365656400000000000000000000000000000000000000000000606482015260840161030a565b60606106fd84845f85610707565b90505b9392505050565b606082471015610799576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c0000000000000000000000000000000000000000000000000000606482015260840161030a565b73ffffffffffffffffffffffffffffffffffffffff85163b610817576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015260640161030a565b5f5f8673ffffffffffffffffffffffffffffffffffffffff16858760405161083f9190610b75565b5f6040518083038185875af1925050503d805f8114610879576040519150601f19603f3d011682016040523d82523d5f602084013e61087e565b606091505b509150915061088e828286610899565b979650505050505050565b606083156108a8575081610700565b8251156108b85782518084602001fd5b816040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161030a9190610b8b565b73ffffffffffffffffffffffffffffffffffffffff8116811461090d575f5ffd5b50565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b6040516020810167ffffffffffffffff8111828210171561096057610960610910565b60405290565b604051601f8201601f1916810167ffffffffffffffff8111828210171561098f5761098f610910565b604052919050565b5f5f5f5f608085870312156109aa575f5ffd5b84356109b5816108ec565b93506020850135925060408501356109cc816108ec565b9150606085013567ffffffffffffffff8111156109e7575f5ffd5b8501601f810187136109f7575f5ffd5b803567ffffffffffffffff811115610a1157610a11610910565b610a246020601f19601f84011601610966565b818152886020838501011115610a38575f5ffd5b816020840160208301375f6020838301015280935050505092959194509250565b5f5f5f5f8486036080811215610a6d575f5ffd5b8535610a78816108ec565b9450602086013593506040860135610a8f816108ec565b925060207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa082011215610ac0575f5ffd5b50610ac961093d565b606095909501358552509194909350909190565b5f6020828403128015610aee575f5ffd5b50610af761093d565b9151825250919050565b5f60208284031215610b11575f5ffd5b5051919050565b80820180821115610b50577f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b92915050565b5f60208284031215610b66575f5ffd5b81518015158114610700575f5ffd5b5f82518060208501845e5f920191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f8301168401019150509291505056fea2646970667358221220ea3a8d8d03a799debe5af38074a1c6538966e823ec47a2dd66481f3c94f2537864736f6c634300081c0033 - /// ``` - #[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\0dW_5`\xE0\x1C\x80cPcL\x0E\x11a\0MW\x80cPcL\x0E\x14a\0\xEEW\x80c\x7F\x81O5\x14a\x01\x03W\x80c\xB9\x93|\xCB\x14a\x01\x16W__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0hW\x80c>\r\xC3N\x14a\0\xB9W[__\xFD[a\0\x8F\x7F\0\0\0\0\0\0\0\0\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\xE0\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xB0V[a\x01\x01a\0\xFC6`\x04a\t\x97V[a\x01=V[\0[a\x01\x01a\x01\x116`\x04a\nYV[a\x01gV[a\0\x8F\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01R\x91\x90a\n\xDDV[\x90Pa\x01`\x85\x85\x85\x84a\x01gV[PPPPPV[a\x01\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x03\xCAV[a\x01\xCAs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\x8EV[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02|W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xA0\x91\x90a\x0B\x01V[\x82Q\x90\x91P\x81\x10\x15a\x03\x13W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03Ts\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\x84\x83a\x05\x89V[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\x88\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xE4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x02W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05&\x91\x90a\x0B\x01V[a\x050\x91\x90a\x0B\x18V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\x88\x90\x85\x90\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\x90`d\x01a\x04$V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x05\xDF\x90\x84\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\x90`d\x01a\x04$V[PPPV[_a\x06E\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\x06\xEF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x05\xDFW\x80\x80` \x01\x90Q\x81\x01\x90a\x06c\x91\x90a\x0BVV[a\x05\xDFW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[``a\x06\xFD\x84\x84_\x85a\x07\x07V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\x99W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\x17W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[__\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\x08?\x91\x90a\x0BuV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08yW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08~V[``\x91P[P\x91P\x91Pa\x08\x8E\x82\x82\x86a\x08\x99V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xA8WP\x81a\x07\0V[\x82Q\x15a\x08\xB8W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\n\x91\x90a\x0B\x8BV[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\t\rW__\xFD[PV[\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`Wa\t`a\t\x10V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\x8FWa\t\x8Fa\t\x10V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xAAW__\xFD[\x845a\t\xB5\x81a\x08\xECV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xCC\x81a\x08\xECV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xE7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\t\xF7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x11Wa\n\x11a\t\x10V[a\n$` `\x1F\x19`\x1F\x84\x01\x16\x01a\tfV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n8W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\nmW__\xFD[\x855a\nx\x81a\x08\xECV[\x94P` \x86\x015\x93P`@\x86\x015a\n\x8F\x81a\x08\xECV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xC0W__\xFD[Pa\n\xC9a\t=V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\n\xEEW__\xFD[Pa\n\xF7a\t=V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\x11W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0BPW\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[_` \x82\x84\x03\x12\x15a\x0BfW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\0W__\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\xFE\xA2dipfsX\"\x12 \xEA:\x8D\x8D\x03\xA7\x99\xDE\xBEZ\xF3\x80t\xA1\xC6S\x89f\xE8#\xECG\xA2\xDDfH\x1F<\x94\xF2SxdsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct StrategySlippageArgs { uint256 amountOutMin; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct StrategySlippageArgs { - #[allow(missing_docs)] - pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: StrategySlippageArgs) -> Self { - (value.amountOutMin,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for StrategySlippageArgs { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { amountOutMin: tuple.0 } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for StrategySlippageArgs { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for StrategySlippageArgs { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for StrategySlippageArgs { - const NAME: &'static str = "StrategySlippageArgs"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "StrategySlippageArgs(uint256 amountOutMin)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) - .0 - .to_vec() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for StrategySlippageArgs { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.amountOutMin, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.amountOutMin, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. -```solidity -event TokenOutput(address tokenReceived, uint256 amountOut); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct TokenOutput { - #[allow(missing_docs)] - pub tokenReceived: alloy::sol_types::private::Address, - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for TokenOutput { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - tokenReceived: data.0, - amountOut: data.1, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.tokenReceived, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountOut), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 TokenOutput { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&TokenOutput> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - /**Constructor`. -```solidity -constructor(address _solvBTCRouter, bytes32 _poolId, address _solvBTC); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct constructorCall { - #[allow(missing_docs)] - pub _solvBTCRouter: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub _poolId: alloy::sol_types::private::FixedBytes<32>, - #[allow(missing_docs)] - pub _solvBTC: alloy::sol_types::private::Address, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - (value._solvBTCRouter, value._poolId, value._solvBTC) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - _solvBTCRouter: tuple.0, - _poolId: tuple.1, - _solvBTC: 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::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._solvBTCRouter, - ), - as alloy_sol_types::SolType>::tokenize(&self._poolId), - ::tokenize( - &self._solvBTC, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. -```solidity -function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub message: alloy::sol_types::private::Bytes, - } - ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ); - #[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, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.message) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - message: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageCall { - 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, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; - const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.message, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. -```solidity -function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub args: ::RustType, - } - ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::primitives::aliases::U256, - alloy::sol_types::private::Address, - ::RustType, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.args) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - args: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageWithSlippageArgsReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageWithSlippageArgsReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; - const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.args, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `poolId()` and selector `0x3e0dc34e`. -```solidity -function poolId() external view returns (bytes32); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct poolIdCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`poolId()`](poolIdCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct poolIdReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: poolIdCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for poolIdCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: poolIdReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for poolIdReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for poolIdCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::FixedBytes<32>; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "poolId()"; - const SELECTOR: [u8; 4] = [62u8, 13u8, 195u8, 78u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: poolIdReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: poolIdReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `solvBTC()` and selector `0xb9937ccb`. -```solidity -function solvBTC() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct solvBTCCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`solvBTC()`](solvBTCCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct solvBTCReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: solvBTCCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for solvBTCCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: solvBTCReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for solvBTCReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for solvBTCCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "solvBTC()"; - const SELECTOR: [u8; 4] = [185u8, 147u8, 124u8, 203u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: solvBTCReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: solvBTCReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `solvBTCRouter()` and selector `0x06af019a`. -```solidity -function solvBTCRouter() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct solvBTCRouterCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`solvBTCRouter()`](solvBTCRouterCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct solvBTCRouterReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: solvBTCRouterCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for solvBTCRouterCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: solvBTCRouterReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for solvBTCRouterReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for solvBTCRouterCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "solvBTCRouter()"; - const SELECTOR: [u8; 4] = [6u8, 175u8, 1u8, 154u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: solvBTCRouterReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: solvBTCRouterReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`SolvBTCStrategy`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum SolvBTCStrategyCalls { - #[allow(missing_docs)] - handleGatewayMessage(handleGatewayMessageCall), - #[allow(missing_docs)] - handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), - #[allow(missing_docs)] - poolId(poolIdCall), - #[allow(missing_docs)] - solvBTC(solvBTCCall), - #[allow(missing_docs)] - solvBTCRouter(solvBTCRouterCall), - } - #[automatically_derived] - impl SolvBTCStrategyCalls { - /// 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, 175u8, 1u8, 154u8], - [62u8, 13u8, 195u8, 78u8], - [80u8, 99u8, 76u8, 14u8], - [127u8, 129u8, 79u8, 53u8], - [185u8, 147u8, 124u8, 203u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for SolvBTCStrategyCalls { - const NAME: &'static str = "SolvBTCStrategyCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 5usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::handleGatewayMessage(_) => { - ::SELECTOR - } - Self::handleGatewayMessageWithSlippageArgs(_) => { - ::SELECTOR - } - Self::poolId(_) => ::SELECTOR, - Self::solvBTC(_) => ::SELECTOR, - Self::solvBTCRouter(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn solvBTCRouter( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SolvBTCStrategyCalls::solvBTCRouter) - } - solvBTCRouter - }, - { - fn poolId( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(SolvBTCStrategyCalls::poolId) - } - poolId - }, - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SolvBTCStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - SolvBTCStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - { - fn solvBTC( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(SolvBTCStrategyCalls::solvBTC) - } - solvBTC - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn solvBTCRouter( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvBTCStrategyCalls::solvBTCRouter) - } - solvBTCRouter - }, - { - fn poolId( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvBTCStrategyCalls::poolId) - } - poolId - }, - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvBTCStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - SolvBTCStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - { - fn solvBTC( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvBTCStrategyCalls::solvBTC) - } - solvBTC - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::handleGatewayMessage(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::poolId(inner) => { - ::abi_encoded_size(inner) - } - Self::solvBTC(inner) => { - ::abi_encoded_size(inner) - } - Self::solvBTCRouter(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::handleGatewayMessage(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::poolId(inner) => { - ::abi_encode_raw(inner, out) - } - Self::solvBTC(inner) => { - ::abi_encode_raw(inner, out) - } - Self::solvBTCRouter(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`SolvBTCStrategy`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum SolvBTCStrategyEvents { - #[allow(missing_docs)] - TokenOutput(TokenOutput), - } - #[automatically_derived] - impl SolvBTCStrategyEvents { - /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for SolvBTCStrategyEvents { - const NAME: &'static str = "SolvBTCStrategyEvents"; - const COUNT: usize = 1usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::TokenOutput) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 SolvBTCStrategyEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`SolvBTCStrategy`](self) contract instance. - -See the [wrapper's documentation](`SolvBTCStrategyInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> SolvBTCStrategyInstance { - SolvBTCStrategyInstance::::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: alloy_contract::private::Network, - >( - provider: P, - _solvBTCRouter: alloy::sol_types::private::Address, - _poolId: alloy::sol_types::private::FixedBytes<32>, - _solvBTC: alloy::sol_types::private::Address, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - SolvBTCStrategyInstance::< - P, - N, - >::deploy(provider, _solvBTCRouter, _poolId, _solvBTC) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - _solvBTCRouter: alloy::sol_types::private::Address, - _poolId: alloy::sol_types::private::FixedBytes<32>, - _solvBTC: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - SolvBTCStrategyInstance::< - P, - N, - >::deploy_builder(provider, _solvBTCRouter, _poolId, _solvBTC) - } - /**A [`SolvBTCStrategy`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`SolvBTCStrategy`](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 SolvBTCStrategyInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for SolvBTCStrategyInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("SolvBTCStrategyInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SolvBTCStrategyInstance { - /**Creates a new wrapper around an on-chain [`SolvBTCStrategy`](self) contract instance. - -See the [wrapper's documentation](`SolvBTCStrategyInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - _solvBTCRouter: alloy::sol_types::private::Address, - _poolId: alloy::sol_types::private::FixedBytes<32>, - _solvBTC: alloy::sol_types::private::Address, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder( - provider, - _solvBTCRouter, - _poolId, - _solvBTC, - ); - 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, - _solvBTCRouter: alloy::sol_types::private::Address, - _poolId: alloy::sol_types::private::FixedBytes<32>, - _solvBTC: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { - _solvBTCRouter, - _poolId, - _solvBTC, - }, - )[..], - ] - .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 SolvBTCStrategyInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> SolvBTCStrategyInstance { - SolvBTCStrategyInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SolvBTCStrategyInstance { - /// 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( - &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 [`handleGatewayMessage`] function. - pub fn handleGatewayMessage( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - message: alloy::sol_types::private::Bytes, - ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { - self.call_builder( - &handleGatewayMessageCall { - tokenSent, - amountIn, - recipient, - message, - }, - ) - } - ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. - pub fn handleGatewayMessageWithSlippageArgs( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - args: ::RustType, - ) -> alloy_contract::SolCallBuilder< - &P, - handleGatewayMessageWithSlippageArgsCall, - N, - > { - self.call_builder( - &handleGatewayMessageWithSlippageArgsCall { - tokenSent, - amountIn, - recipient, - args, - }, - ) - } - ///Creates a new call builder for the [`poolId`] function. - pub fn poolId(&self) -> alloy_contract::SolCallBuilder<&P, poolIdCall, N> { - self.call_builder(&poolIdCall) - } - ///Creates a new call builder for the [`solvBTC`] function. - pub fn solvBTC(&self) -> alloy_contract::SolCallBuilder<&P, solvBTCCall, N> { - self.call_builder(&solvBTCCall) - } - ///Creates a new call builder for the [`solvBTCRouter`] function. - pub fn solvBTCRouter( - &self, - ) -> alloy_contract::SolCallBuilder<&P, solvBTCRouterCall, N> { - self.call_builder(&solvBTCRouterCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SolvBTCStrategyInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`TokenOutput`] event. - pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/solv_lst_strategy.rs b/crates/bindings/src/solv_lst_strategy.rs deleted file mode 100644 index 1d5d910a1..000000000 --- a/crates/bindings/src/solv_lst_strategy.rs +++ /dev/null @@ -1,2695 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface SolvLSTStrategy { - struct StrategySlippageArgs { - uint256 amountOutMin; - } - - event TokenOutput(address tokenReceived, uint256 amountOut); - - constructor(address _solvBTCRouter, address _solvLSTRouter, bytes32 _solvBTCPoolId, bytes32 _solvLSTPoolId, address _solvBTC, address _solvLST); - - function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; - function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; - function solvBTC() external view returns (address); - function solvBTCPoolId() external view returns (bytes32); - function solvBTCRouter() external view returns (address); - function solvLST() external view returns (address); - function solvLSTPoolId() external view returns (bytes32); - function solvLSTRouter() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "constructor", - "inputs": [ - { - "name": "_solvBTCRouter", - "type": "address", - "internalType": "contract ISolvBTCRouter" - }, - { - "name": "_solvLSTRouter", - "type": "address", - "internalType": "contract ISolvBTCRouter" - }, - { - "name": "_solvBTCPoolId", - "type": "bytes32", - "internalType": "bytes32" - }, - { - "name": "_solvLSTPoolId", - "type": "bytes32", - "internalType": "bytes32" - }, - { - "name": "_solvBTC", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "_solvLST", - "type": "address", - "internalType": "contract IERC20" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessage", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "message", - "type": "bytes", - "internalType": "bytes" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "handleGatewayMessageWithSlippageArgs", - "inputs": [ - { - "name": "tokenSent", - "type": "address", - "internalType": "contract IERC20" - }, - { - "name": "amountIn", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "recipient", - "type": "address", - "internalType": "address" - }, - { - "name": "args", - "type": "tuple", - "internalType": "struct StrategySlippageArgs", - "components": [ - { - "name": "amountOutMin", - "type": "uint256", - "internalType": "uint256" - } - ] - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "solvBTC", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IERC20" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "solvBTCPoolId", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bytes32", - "internalType": "bytes32" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "solvBTCRouter", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract ISolvBTCRouter" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "solvLST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IERC20" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "solvLSTPoolId", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bytes32", - "internalType": "bytes32" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "solvLSTRouter", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract ISolvBTCRouter" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "TokenOutput", - "inputs": [ - { - "name": "tokenReceived", - "type": "address", - "indexed": false, - "internalType": "address" - }, - { - "name": "amountOut", - "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 SolvLSTStrategy { - use super::*; - use alloy::sol_types as 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__\xFD[P`@Qa\x0F-8\x03\x80a\x0F-\x839\x81\x01`@\x81\x90Ra\0/\x91a\0sV[`\x01`\x01`\xA0\x1B\x03\x95\x86\x16`\x80R\x93\x85\x16`\xA0R`\xC0\x92\x90\x92R`\xE0R\x82\x16a\x01\0R\x16a\x01 Ra\0\xE3V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0pW__\xFD[PV[______`\xC0\x87\x89\x03\x12\x15a\0\x88W__\xFD[\x86Qa\0\x93\x81a\0\\V[` \x88\x01Q\x90\x96Pa\0\xA4\x81a\0\\V[`@\x88\x01Q``\x89\x01Q`\x80\x8A\x01Q\x92\x97P\x90\x95P\x93Pa\0\xC4\x81a\0\\V[`\xA0\x88\x01Q\x90\x92Pa\0\xD5\x81a\0\\V[\x80\x91PP\x92\x95P\x92\x95P\x92\x95V[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\r\xC6a\x01g_9_\x81\x81a\x01.\x01R\x81\x81a\x04\xFC\x01Ra\x05>\x01R_\x81\x81a\x01U\x01Ra\x03R\x01R_\x81\x81a\x01\xB1\x01Ra\x03\xC1\x01R_\x81\x81a\x01|\x01Ra\x02\x88\x01R_\x81\x81`\xDF\x01R\x81\x81a\x03t\x01Ra\x03\xF0\x01R_\x81\x81`\x8E\x01R\x81\x81a\x02;\x01Ra\x02\xB7\x01Ra\r\xC6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\x85W_5`\xE0\x1C\x80c\xADt}\xE6\x11a\0XW\x80c\xADt}\xE6\x14a\x01)W\x80c\xB9\x93|\xCB\x14a\x01PW\x80c\xC8\xC7\xF7\x01\x14a\x01wW\x80c\xE3L\xEF\x86\x14a\x01\xACW__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0\x89W\x80cN=\xF3\xF4\x14a\0\xDAW\x80cPcL\x0E\x14a\x01\x01W\x80c\x7F\x81O5\x14a\x01\x16W[__\xFD[a\0\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\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\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\x81V[a\x01\x14a\x01\x0F6`\x04a\x0BgV[a\x01\xD3V[\0[a\x01\x14a\x01$6`\x04a\x0C)V[a\x01\xFDV[a\0\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\x81V[a\0\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\x81V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xD1V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\xE8\x91\x90a\x0C\xADV[\x90Pa\x01\xF6\x85\x85\x85\x84a\x01\xFDV[PPPPPV[a\x02\x1Fs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x9AV[a\x02`s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x036\x91\x90a\x0C\xD1V[\x90Pa\x03\x99s\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\x7F\0\0\0\0\0\0\0\0\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\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x82\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04KW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04o\x91\x90a\x0C\xD1V[\x83Q\x90\x91P\x81\x10\x15a\x04\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[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\x85\x83a\x07YV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x06X\x90\x85\x90\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\x90`\x84\x01[`@\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\x07\xB4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF6\x91\x90a\x0C\xD1V[a\x07\0\x91\x90a\x0C\xE8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x06X\x90\x85\x90\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\x90`d\x01a\x05\xF4V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07\xAF\x90\x84\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\x90`d\x01a\x05\xF4V[PPPV[_a\x08\x15\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\x08\xBF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\xAFW\x80\x80` \x01\x90Q\x81\x01\x90a\x083\x91\x90a\r&V[a\x07\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\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\x04\xD9V[``a\x08\xCD\x84\x84_\x85a\x08\xD7V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\tiW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x04\xD9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\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`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x04\xD9V[__\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\n\x0F\x91\x90a\rEV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\nIW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\nNV[``\x91P[P\x91P\x91Pa\n^\x82\x82\x86a\niV[\x97\x96PPPPPPPV[``\x83\x15a\nxWP\x81a\x08\xD0V[\x82Q\x15a\n\x88W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x04\xD9\x91\x90a\r[V[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\xDDW__\xFD[PV[\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\x0B0Wa\x0B0a\n\xE0V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0B_Wa\x0B_a\n\xE0V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0BzW__\xFD[\x845a\x0B\x85\x81a\n\xBCV[\x93P` \x85\x015\x92P`@\x85\x015a\x0B\x9C\x81a\n\xBCV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xB7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\x0B\xC7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xE1Wa\x0B\xE1a\n\xE0V[a\x0B\xF4` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0B6V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0C\x08W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0C=W__\xFD[\x855a\x0CH\x81a\n\xBCV[\x94P` \x86\x015\x93P`@\x86\x015a\x0C_\x81a\n\xBCV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0C\x90W__\xFD[Pa\x0C\x99a\x0B\rV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0C\xBEW__\xFD[Pa\x0C\xC7a\x0B\rV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C\xE1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\r 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[_` \x82\x84\x03\x12\x15a\r6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x08\xD0W__\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\xFE\xA2dipfsX\"\x12 \xD28\x8C\xB3\xDCz\xA6\xF5\xA2\xEBuA}\x11\x05\x9B\xE1<\x8C\x9E\xAB\xE5\xD7\xEA\xDB\x1BV\x1F\x93\x7F\xF6\x91dsolcC\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\0\x85W_5`\xE0\x1C\x80c\xADt}\xE6\x11a\0XW\x80c\xADt}\xE6\x14a\x01)W\x80c\xB9\x93|\xCB\x14a\x01PW\x80c\xC8\xC7\xF7\x01\x14a\x01wW\x80c\xE3L\xEF\x86\x14a\x01\xACW__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0\x89W\x80cN=\xF3\xF4\x14a\0\xDAW\x80cPcL\x0E\x14a\x01\x01W\x80c\x7F\x81O5\x14a\x01\x16W[__\xFD[a\0\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\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\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\x81V[a\x01\x14a\x01\x0F6`\x04a\x0BgV[a\x01\xD3V[\0[a\x01\x14a\x01$6`\x04a\x0C)V[a\x01\xFDV[a\0\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\x81V[a\0\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\x81V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xD1V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\xE8\x91\x90a\x0C\xADV[\x90Pa\x01\xF6\x85\x85\x85\x84a\x01\xFDV[PPPPPV[a\x02\x1Fs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x9AV[a\x02`s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x036\x91\x90a\x0C\xD1V[\x90Pa\x03\x99s\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\x7F\0\0\0\0\0\0\0\0\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\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x82\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04KW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04o\x91\x90a\x0C\xD1V[\x83Q\x90\x91P\x81\x10\x15a\x04\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[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\x85\x83a\x07YV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x06X\x90\x85\x90\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\x90`\x84\x01[`@\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\x07\xB4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF6\x91\x90a\x0C\xD1V[a\x07\0\x91\x90a\x0C\xE8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x06X\x90\x85\x90\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\x90`d\x01a\x05\xF4V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07\xAF\x90\x84\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\x90`d\x01a\x05\xF4V[PPPV[_a\x08\x15\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\x08\xBF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\xAFW\x80\x80` \x01\x90Q\x81\x01\x90a\x083\x91\x90a\r&V[a\x07\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\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\x04\xD9V[``a\x08\xCD\x84\x84_\x85a\x08\xD7V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\tiW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x04\xD9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\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`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x04\xD9V[__\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\n\x0F\x91\x90a\rEV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\nIW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\nNV[``\x91P[P\x91P\x91Pa\n^\x82\x82\x86a\niV[\x97\x96PPPPPPPV[``\x83\x15a\nxWP\x81a\x08\xD0V[\x82Q\x15a\n\x88W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x04\xD9\x91\x90a\r[V[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\xDDW__\xFD[PV[\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\x0B0Wa\x0B0a\n\xE0V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0B_Wa\x0B_a\n\xE0V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0BzW__\xFD[\x845a\x0B\x85\x81a\n\xBCV[\x93P` \x85\x015\x92P`@\x85\x015a\x0B\x9C\x81a\n\xBCV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xB7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\x0B\xC7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xE1Wa\x0B\xE1a\n\xE0V[a\x0B\xF4` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0B6V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0C\x08W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0C=W__\xFD[\x855a\x0CH\x81a\n\xBCV[\x94P` \x86\x015\x93P`@\x86\x015a\x0C_\x81a\n\xBCV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0C\x90W__\xFD[Pa\x0C\x99a\x0B\rV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0C\xBEW__\xFD[Pa\x0C\xC7a\x0B\rV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C\xE1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\r 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[_` \x82\x84\x03\x12\x15a\r6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x08\xD0W__\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\xFE\xA2dipfsX\"\x12 \xD28\x8C\xB3\xDCz\xA6\xF5\xA2\xEBuA}\x11\x05\x9B\xE1<\x8C\x9E\xAB\xE5\xD7\xEA\xDB\x1BV\x1F\x93\x7F\xF6\x91dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct StrategySlippageArgs { uint256 amountOutMin; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct StrategySlippageArgs { - #[allow(missing_docs)] - pub amountOutMin: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: StrategySlippageArgs) -> Self { - (value.amountOutMin,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for StrategySlippageArgs { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { amountOutMin: tuple.0 } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for StrategySlippageArgs { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for StrategySlippageArgs { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.amountOutMin), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for StrategySlippageArgs { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for StrategySlippageArgs { - const NAME: &'static str = "StrategySlippageArgs"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "StrategySlippageArgs(uint256 amountOutMin)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - as alloy_sol_types::SolType>::eip712_data_word(&self.amountOutMin) - .0 - .to_vec() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for StrategySlippageArgs { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.amountOutMin, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.amountOutMin, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `TokenOutput(address,uint256)` and selector `0x0c7dc5ac7999dcaf43e15e5be6eb5a5e2ae426840df301ca0b6463a6d797988d`. -```solidity -event TokenOutput(address tokenReceived, uint256 amountOut); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct TokenOutput { - #[allow(missing_docs)] - pub tokenReceived: alloy::sol_types::private::Address, - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for TokenOutput { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "TokenOutput(address,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 12u8, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - tokenReceived: data.0, - amountOut: data.1, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.tokenReceived, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountOut), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 TokenOutput { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&TokenOutput> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &TokenOutput) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - /**Constructor`. -```solidity -constructor(address _solvBTCRouter, address _solvLSTRouter, bytes32 _solvBTCPoolId, bytes32 _solvLSTPoolId, address _solvBTC, address _solvLST); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct constructorCall { - #[allow(missing_docs)] - pub _solvBTCRouter: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub _solvLSTRouter: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub _solvBTCPoolId: alloy::sol_types::private::FixedBytes<32>, - #[allow(missing_docs)] - pub _solvLSTPoolId: alloy::sol_types::private::FixedBytes<32>, - #[allow(missing_docs)] - pub _solvBTC: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub _solvLST: alloy::sol_types::private::Address, - } - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - 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, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Address, - alloy::sol_types::private::FixedBytes<32>, - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: constructorCall) -> Self { - ( - value._solvBTCRouter, - value._solvLSTRouter, - value._solvBTCPoolId, - value._solvLSTPoolId, - value._solvBTC, - value._solvLST, - ) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for constructorCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - _solvBTCRouter: tuple.0, - _solvLSTRouter: tuple.1, - _solvBTCPoolId: tuple.2, - _solvLSTPoolId: tuple.3, - _solvBTC: tuple.4, - _solvLST: tuple.5, - } - } - } - } - #[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::FixedBytes<32>, - alloy::sol_types::sol_data::FixedBytes<32>, - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Address, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self._solvBTCRouter, - ), - ::tokenize( - &self._solvLSTRouter, - ), - as alloy_sol_types::SolType>::tokenize(&self._solvBTCPoolId), - as alloy_sol_types::SolType>::tokenize(&self._solvLSTPoolId), - ::tokenize( - &self._solvBTC, - ), - ::tokenize( - &self._solvLST, - ), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessage(address,uint256,address,bytes)` and selector `0x50634c0e`. -```solidity -function handleGatewayMessage(address tokenSent, uint256 amountIn, address recipient, bytes memory message) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub message: alloy::sol_types::private::Bytes, - } - ///Container type for the return parameters of the [`handleGatewayMessage(address,uint256,address,bytes)`](handleGatewayMessageCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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, - ); - #[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, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.message) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - message: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageCall { - 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, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessage(address,uint256,address,bytes)"; - const SELECTOR: [u8; 4] = [80u8, 99u8, 76u8, 14u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.message, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))` and selector `0x7f814f35`. -```solidity -function handleGatewayMessageWithSlippageArgs(address tokenSent, uint256 amountIn, address recipient, StrategySlippageArgs memory args) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsCall { - #[allow(missing_docs)] - pub tokenSent: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub amountIn: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub recipient: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub args: ::RustType, - } - ///Container type for the return parameters of the [`handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))`](handleGatewayMessageWithSlippageArgsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct handleGatewayMessageWithSlippageArgsReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::primitives::aliases::U256, - alloy::sol_types::private::Address, - ::RustType, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsCall) -> Self { - (value.tokenSent, value.amountIn, value.recipient, value.args) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - tokenSent: tuple.0, - amountIn: tuple.1, - recipient: tuple.2, - args: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: handleGatewayMessageWithSlippageArgsReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for handleGatewayMessageWithSlippageArgsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl handleGatewayMessageWithSlippageArgsReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for handleGatewayMessageWithSlippageArgsCall { - type Parameters<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Address, - StrategySlippageArgs, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = handleGatewayMessageWithSlippageArgsReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "handleGatewayMessageWithSlippageArgs(address,uint256,address,(uint256))"; - const SELECTOR: [u8; 4] = [127u8, 129u8, 79u8, 53u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - ::tokenize( - &self.tokenSent, - ), - as alloy_sol_types::SolType>::tokenize(&self.amountIn), - ::tokenize( - &self.recipient, - ), - ::tokenize( - &self.args, - ), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - handleGatewayMessageWithSlippageArgsReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `solvBTC()` and selector `0xb9937ccb`. -```solidity -function solvBTC() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct solvBTCCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`solvBTC()`](solvBTCCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct solvBTCReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: solvBTCCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for solvBTCCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: solvBTCReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for solvBTCReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for solvBTCCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "solvBTC()"; - const SELECTOR: [u8; 4] = [185u8, 147u8, 124u8, 203u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: solvBTCReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: solvBTCReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `solvBTCPoolId()` and selector `0xc8c7f701`. -```solidity -function solvBTCPoolId() external view returns (bytes32); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct solvBTCPoolIdCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`solvBTCPoolId()`](solvBTCPoolIdCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct solvBTCPoolIdReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: solvBTCPoolIdCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for solvBTCPoolIdCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: solvBTCPoolIdReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for solvBTCPoolIdReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for solvBTCPoolIdCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::FixedBytes<32>; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "solvBTCPoolId()"; - const SELECTOR: [u8; 4] = [200u8, 199u8, 247u8, 1u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: solvBTCPoolIdReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: solvBTCPoolIdReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `solvBTCRouter()` and selector `0x06af019a`. -```solidity -function solvBTCRouter() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct solvBTCRouterCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`solvBTCRouter()`](solvBTCRouterCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct solvBTCRouterReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: solvBTCRouterCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for solvBTCRouterCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: solvBTCRouterReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for solvBTCRouterReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for solvBTCRouterCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "solvBTCRouter()"; - const SELECTOR: [u8; 4] = [6u8, 175u8, 1u8, 154u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: solvBTCRouterReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: solvBTCRouterReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `solvLST()` and selector `0xad747de6`. -```solidity -function solvLST() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct solvLSTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`solvLST()`](solvLSTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct solvLSTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: solvLSTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for solvLSTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: solvLSTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for solvLSTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for solvLSTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "solvLST()"; - const SELECTOR: [u8; 4] = [173u8, 116u8, 125u8, 230u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: solvLSTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: solvLSTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `solvLSTPoolId()` and selector `0xe34cef86`. -```solidity -function solvLSTPoolId() external view returns (bytes32); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct solvLSTPoolIdCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`solvLSTPoolId()`](solvLSTPoolIdCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct solvLSTPoolIdReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: solvLSTPoolIdCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for solvLSTPoolIdCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: solvLSTPoolIdReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for solvLSTPoolIdReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for solvLSTPoolIdCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::FixedBytes<32>; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "solvLSTPoolId()"; - const SELECTOR: [u8; 4] = [227u8, 76u8, 239u8, 134u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: solvLSTPoolIdReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: solvLSTPoolIdReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `solvLSTRouter()` and selector `0x4e3df3f4`. -```solidity -function solvLSTRouter() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct solvLSTRouterCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`solvLSTRouter()`](solvLSTRouterCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct solvLSTRouterReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: solvLSTRouterCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for solvLSTRouterCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: solvLSTRouterReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for solvLSTRouterReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for solvLSTRouterCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "solvLSTRouter()"; - const SELECTOR: [u8; 4] = [78u8, 61u8, 243u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: solvLSTRouterReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: solvLSTRouterReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`SolvLSTStrategy`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum SolvLSTStrategyCalls { - #[allow(missing_docs)] - handleGatewayMessage(handleGatewayMessageCall), - #[allow(missing_docs)] - handleGatewayMessageWithSlippageArgs(handleGatewayMessageWithSlippageArgsCall), - #[allow(missing_docs)] - solvBTC(solvBTCCall), - #[allow(missing_docs)] - solvBTCPoolId(solvBTCPoolIdCall), - #[allow(missing_docs)] - solvBTCRouter(solvBTCRouterCall), - #[allow(missing_docs)] - solvLST(solvLSTCall), - #[allow(missing_docs)] - solvLSTPoolId(solvLSTPoolIdCall), - #[allow(missing_docs)] - solvLSTRouter(solvLSTRouterCall), - } - #[automatically_derived] - impl SolvLSTStrategyCalls { - /// 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, 175u8, 1u8, 154u8], - [78u8, 61u8, 243u8, 244u8], - [80u8, 99u8, 76u8, 14u8], - [127u8, 129u8, 79u8, 53u8], - [173u8, 116u8, 125u8, 230u8], - [185u8, 147u8, 124u8, 203u8], - [200u8, 199u8, 247u8, 1u8], - [227u8, 76u8, 239u8, 134u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for SolvLSTStrategyCalls { - const NAME: &'static str = "SolvLSTStrategyCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 8usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::handleGatewayMessage(_) => { - ::SELECTOR - } - Self::handleGatewayMessageWithSlippageArgs(_) => { - ::SELECTOR - } - Self::solvBTC(_) => ::SELECTOR, - Self::solvBTCPoolId(_) => { - ::SELECTOR - } - Self::solvBTCRouter(_) => { - ::SELECTOR - } - Self::solvLST(_) => ::SELECTOR, - Self::solvLSTPoolId(_) => { - ::SELECTOR - } - Self::solvLSTRouter(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn solvBTCRouter( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SolvLSTStrategyCalls::solvBTCRouter) - } - solvBTCRouter - }, - { - fn solvLSTRouter( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SolvLSTStrategyCalls::solvLSTRouter) - } - solvLSTRouter - }, - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SolvLSTStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map( - SolvLSTStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - { - fn solvLST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(SolvLSTStrategyCalls::solvLST) - } - solvLST - }, - { - fn solvBTC( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(SolvLSTStrategyCalls::solvBTC) - } - solvBTC - }, - { - fn solvBTCPoolId( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SolvLSTStrategyCalls::solvBTCPoolId) - } - solvBTCPoolId - }, - { - fn solvLSTPoolId( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SolvLSTStrategyCalls::solvLSTPoolId) - } - solvLSTPoolId - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn solvBTCRouter( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvLSTStrategyCalls::solvBTCRouter) - } - solvBTCRouter - }, - { - fn solvLSTRouter( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvLSTStrategyCalls::solvLSTRouter) - } - solvLSTRouter - }, - { - fn handleGatewayMessage( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvLSTStrategyCalls::handleGatewayMessage) - } - handleGatewayMessage - }, - { - fn handleGatewayMessageWithSlippageArgs( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map( - SolvLSTStrategyCalls::handleGatewayMessageWithSlippageArgs, - ) - } - handleGatewayMessageWithSlippageArgs - }, - { - fn solvLST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvLSTStrategyCalls::solvLST) - } - solvLST - }, - { - fn solvBTC( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvLSTStrategyCalls::solvBTC) - } - solvBTC - }, - { - fn solvBTCPoolId( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvLSTStrategyCalls::solvBTCPoolId) - } - solvBTCPoolId - }, - { - fn solvLSTPoolId( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvLSTStrategyCalls::solvLSTPoolId) - } - solvLSTPoolId - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::handleGatewayMessage(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::solvBTC(inner) => { - ::abi_encoded_size(inner) - } - Self::solvBTCPoolId(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::solvBTCRouter(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::solvLST(inner) => { - ::abi_encoded_size(inner) - } - Self::solvLSTPoolId(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::solvLSTRouter(inner) => { - ::abi_encoded_size( - inner, - ) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::handleGatewayMessage(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::handleGatewayMessageWithSlippageArgs(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::solvBTC(inner) => { - ::abi_encode_raw(inner, out) - } - Self::solvBTCPoolId(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::solvBTCRouter(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::solvLST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::solvLSTPoolId(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::solvLSTRouter(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`SolvLSTStrategy`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum SolvLSTStrategyEvents { - #[allow(missing_docs)] - TokenOutput(TokenOutput), - } - #[automatically_derived] - impl SolvLSTStrategyEvents { - /// 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, 125u8, 197u8, 172u8, 121u8, 153u8, 220u8, 175u8, 67u8, 225u8, 94u8, - 91u8, 230u8, 235u8, 90u8, 94u8, 42u8, 228u8, 38u8, 132u8, 13u8, 243u8, - 1u8, 202u8, 11u8, 100u8, 99u8, 166u8, 215u8, 151u8, 152u8, 141u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for SolvLSTStrategyEvents { - const NAME: &'static str = "SolvLSTStrategyEvents"; - const COUNT: usize = 1usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::TokenOutput) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 SolvLSTStrategyEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::TokenOutput(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`SolvLSTStrategy`](self) contract instance. - -See the [wrapper's documentation](`SolvLSTStrategyInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> SolvLSTStrategyInstance { - SolvLSTStrategyInstance::::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: alloy_contract::private::Network, - >( - provider: P, - _solvBTCRouter: alloy::sol_types::private::Address, - _solvLSTRouter: alloy::sol_types::private::Address, - _solvBTCPoolId: alloy::sol_types::private::FixedBytes<32>, - _solvLSTPoolId: alloy::sol_types::private::FixedBytes<32>, - _solvBTC: alloy::sol_types::private::Address, - _solvLST: alloy::sol_types::private::Address, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - SolvLSTStrategyInstance::< - P, - N, - >::deploy( - provider, - _solvBTCRouter, - _solvLSTRouter, - _solvBTCPoolId, - _solvLSTPoolId, - _solvBTC, - _solvLST, - ) - } - /**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: alloy_contract::private::Network, - >( - provider: P, - _solvBTCRouter: alloy::sol_types::private::Address, - _solvLSTRouter: alloy::sol_types::private::Address, - _solvBTCPoolId: alloy::sol_types::private::FixedBytes<32>, - _solvLSTPoolId: alloy::sol_types::private::FixedBytes<32>, - _solvBTC: alloy::sol_types::private::Address, - _solvLST: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - SolvLSTStrategyInstance::< - P, - N, - >::deploy_builder( - provider, - _solvBTCRouter, - _solvLSTRouter, - _solvBTCPoolId, - _solvLSTPoolId, - _solvBTC, - _solvLST, - ) - } - /**A [`SolvLSTStrategy`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`SolvLSTStrategy`](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 SolvLSTStrategyInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for SolvLSTStrategyInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("SolvLSTStrategyInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SolvLSTStrategyInstance { - /**Creates a new wrapper around an on-chain [`SolvLSTStrategy`](self) contract instance. - -See the [wrapper's documentation](`SolvLSTStrategyInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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, - _solvBTCRouter: alloy::sol_types::private::Address, - _solvLSTRouter: alloy::sol_types::private::Address, - _solvBTCPoolId: alloy::sol_types::private::FixedBytes<32>, - _solvLSTPoolId: alloy::sol_types::private::FixedBytes<32>, - _solvBTC: alloy::sol_types::private::Address, - _solvLST: alloy::sol_types::private::Address, - ) -> alloy_contract::Result> { - let call_builder = Self::deploy_builder( - provider, - _solvBTCRouter, - _solvLSTRouter, - _solvBTCPoolId, - _solvLSTPoolId, - _solvBTC, - _solvLST, - ); - 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, - _solvBTCRouter: alloy::sol_types::private::Address, - _solvLSTRouter: alloy::sol_types::private::Address, - _solvBTCPoolId: alloy::sol_types::private::FixedBytes<32>, - _solvLSTPoolId: alloy::sol_types::private::FixedBytes<32>, - _solvBTC: alloy::sol_types::private::Address, - _solvLST: alloy::sol_types::private::Address, - ) -> alloy_contract::RawCallBuilder { - alloy_contract::RawCallBuilder::new_raw_deploy( - provider, - [ - &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode( - &constructorCall { - _solvBTCRouter, - _solvLSTRouter, - _solvBTCPoolId, - _solvLSTPoolId, - _solvBTC, - _solvLST, - }, - )[..], - ] - .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 SolvLSTStrategyInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> SolvLSTStrategyInstance { - SolvLSTStrategyInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SolvLSTStrategyInstance { - /// 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( - &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 [`handleGatewayMessage`] function. - pub fn handleGatewayMessage( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - message: alloy::sol_types::private::Bytes, - ) -> alloy_contract::SolCallBuilder<&P, handleGatewayMessageCall, N> { - self.call_builder( - &handleGatewayMessageCall { - tokenSent, - amountIn, - recipient, - message, - }, - ) - } - ///Creates a new call builder for the [`handleGatewayMessageWithSlippageArgs`] function. - pub fn handleGatewayMessageWithSlippageArgs( - &self, - tokenSent: alloy::sol_types::private::Address, - amountIn: alloy::sol_types::private::primitives::aliases::U256, - recipient: alloy::sol_types::private::Address, - args: ::RustType, - ) -> alloy_contract::SolCallBuilder< - &P, - handleGatewayMessageWithSlippageArgsCall, - N, - > { - self.call_builder( - &handleGatewayMessageWithSlippageArgsCall { - tokenSent, - amountIn, - recipient, - args, - }, - ) - } - ///Creates a new call builder for the [`solvBTC`] function. - pub fn solvBTC(&self) -> alloy_contract::SolCallBuilder<&P, solvBTCCall, N> { - self.call_builder(&solvBTCCall) - } - ///Creates a new call builder for the [`solvBTCPoolId`] function. - pub fn solvBTCPoolId( - &self, - ) -> alloy_contract::SolCallBuilder<&P, solvBTCPoolIdCall, N> { - self.call_builder(&solvBTCPoolIdCall) - } - ///Creates a new call builder for the [`solvBTCRouter`] function. - pub fn solvBTCRouter( - &self, - ) -> alloy_contract::SolCallBuilder<&P, solvBTCRouterCall, N> { - self.call_builder(&solvBTCRouterCall) - } - ///Creates a new call builder for the [`solvLST`] function. - pub fn solvLST(&self) -> alloy_contract::SolCallBuilder<&P, solvLSTCall, N> { - self.call_builder(&solvLSTCall) - } - ///Creates a new call builder for the [`solvLSTPoolId`] function. - pub fn solvLSTPoolId( - &self, - ) -> alloy_contract::SolCallBuilder<&P, solvLSTPoolIdCall, N> { - self.call_builder(&solvLSTPoolIdCall) - } - ///Creates a new call builder for the [`solvLSTRouter`] function. - pub fn solvLSTRouter( - &self, - ) -> alloy_contract::SolCallBuilder<&P, solvLSTRouterCall, N> { - self.call_builder(&solvLSTRouterCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SolvLSTStrategyInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`TokenOutput`] event. - pub fn TokenOutput_filter(&self) -> alloy_contract::Event<&P, TokenOutput, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/solv_strategy_forked.rs b/crates/bindings/src/solv_strategy_forked.rs deleted file mode 100644 index 66be6dd68..000000000 --- a/crates/bindings/src/solv_strategy_forked.rs +++ /dev/null @@ -1,8183 +0,0 @@ -///Module containing a contract's types and functions. -/** - -```solidity -library StdInvariant { - struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } - struct FuzzInterface { address addr; string[] artifacts; } - struct FuzzSelector { address addr; bytes4[] selectors; } -} -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdInvariant { - use super::*; - use alloy::sol_types as alloy_sol_types; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzArtifactSelector { string artifact; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzArtifactSelector { - #[allow(missing_docs)] - pub artifact: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::String, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzArtifactSelector) -> Self { - (value.artifact, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzArtifactSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - artifact: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzArtifactSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzArtifactSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.artifact, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzArtifactSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzArtifactSelector { - const NAME: &'static str = "FuzzArtifactSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzArtifactSelector(string artifact,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.artifact, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzArtifactSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.artifact, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.artifact, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzInterface { address addr; string[] artifacts; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzInterface { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub artifacts: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzInterface) -> Self { - (value.addr, value.artifacts) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzInterface { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - artifacts: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzInterface { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzInterface { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - as alloy_sol_types::SolType>::tokenize(&self.artifacts), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzInterface { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzInterface { - const NAME: &'static str = "FuzzInterface"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzInterface(address addr,string[] artifacts)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - as alloy_sol_types::SolType>::eip712_data_word(&self.artifacts) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzInterface { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.artifacts, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.artifacts, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**```solidity -struct FuzzSelector { address addr; bytes4[] selectors; } -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct FuzzSelector { - #[allow(missing_docs)] - pub addr: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub selectors: alloy::sol_types::private::Vec< - 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 as alloy_sol_types; - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Address, - alloy::sol_types::sol_data::Array>, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Address, - alloy::sol_types::private::Vec>, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: FuzzSelector) -> Self { - (value.addr, value.selectors) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for FuzzSelector { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - addr: tuple.0, - selectors: tuple.1, - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolValue for FuzzSelector { - type SolType = Self; - } - #[automatically_derived] - impl alloy_sol_types::private::SolTypeValue for FuzzSelector { - #[inline] - fn stv_to_tokens(&self) -> ::Token<'_> { - ( - ::tokenize( - &self.addr, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.selectors), - ) - } - #[inline] - fn stv_abi_encoded_size(&self) -> usize { - if let Some(size) = ::ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) - } - #[inline] - fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - ::eip712_hash_struct(self) - } - #[inline] - fn stv_abi_encode_packed_to( - &self, - out: &mut alloy_sol_types::private::Vec, - ) { - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) - } - #[inline] - fn stv_abi_packed_encoded_size(&self) -> usize { - if let Some(size) = ::PACKED_ENCODED_SIZE { - return size; - } - let tuple = as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolType for FuzzSelector { - type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; - #[inline] - fn valid_token(token: &Self::Token<'_>) -> bool { - as alloy_sol_types::SolType>::valid_token(token) - } - #[inline] - fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); - >>::from(tuple) - } - } - #[automatically_derived] - impl alloy_sol_types::SolStruct for FuzzSelector { - const NAME: &'static str = "FuzzSelector"; - #[inline] - fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed( - "FuzzSelector(address addr,bytes4[] selectors)", - ) - } - #[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> { - ::eip712_root_type() - } - #[inline] - fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { - [ - ::eip712_data_word( - &self.addr, - ) - .0, - , - > as alloy_sol_types::SolType>::eip712_data_word(&self.selectors) - .0, - ] - .concat() - } - } - #[automatically_derived] - impl alloy_sol_types::EventTopic for FuzzSelector { - #[inline] - fn topic_preimage_length(rust: &Self::RustType) -> usize { - 0usize - + ::topic_preimage_length( - &rust.addr, - ) - + , - > as alloy_sol_types::EventTopic>::topic_preimage_length( - &rust.selectors, - ) - } - #[inline] - fn encode_topic_preimage( - rust: &Self::RustType, - out: &mut alloy_sol_types::private::Vec, - ) { - out.reserve( - ::topic_preimage_length(rust), - ); - ::encode_topic_preimage( - &rust.addr, - out, - ); - , - > as alloy_sol_types::EventTopic>::encode_topic_preimage( - &rust.selectors, - out, - ); - } - #[inline] - fn encode_topic( - rust: &Self::RustType, - ) -> alloy_sol_types::abi::token::WordToken { - let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage( - rust, - &mut out, - ); - alloy_sol_types::abi::token::WordToken( - alloy_sol_types::private::keccak256(out), - ) - } - } - }; - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdInvariantInstance { - StdInvariantInstance::::new(address, provider) - } - /**A [`StdInvariant`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdInvariant`](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 StdInvariantInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdInvariantInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdInvariantInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /**Creates a new wrapper around an on-chain [`StdInvariant`](self) contract instance. - -See the [wrapper's documentation](`StdInvariantInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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 StdInvariantInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdInvariantInstance { - StdInvariantInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdInvariantInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} -/** - -Generated by the following Solidity interface... -```solidity -library StdInvariant { - struct FuzzArtifactSelector { - string artifact; - bytes4[] selectors; - } - struct FuzzInterface { - address addr; - string[] artifacts; - } - struct FuzzSelector { - address addr; - bytes4[] selectors; - } -} - -interface SolvStrategyForked { - event log(string); - event log_address(address); - event log_array(uint256[] val); - event log_array(int256[] val); - event log_array(address[] val); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_array(string key, uint256[] val); - event log_named_array(string key, int256[] val); - event log_named_array(string key, address[] val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - function IS_TEST() external view returns (bool); - function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); - function excludeContracts() external view returns (address[] memory excludedContracts_); - function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); - function excludeSenders() external view returns (address[] memory excludedSenders_); - function failed() external view returns (bool); - function setUp() external; - function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; - function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); - function targetArtifacts() external view returns (string[] memory targetedArtifacts_); - function targetContracts() external view returns (address[] memory targetedContracts_); - function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); - function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); - function targetSenders() external view returns (address[] memory targetedSenders_); - function testSolvBTCStrategy() external; - function testSolvLSTStrategy() external; - function token() external view returns (address); -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeArtifacts", - "inputs": [], - "outputs": [ - { - "name": "excludedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeContracts", - "inputs": [], - "outputs": [ - { - "name": "excludedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSelectors", - "inputs": [], - "outputs": [ - { - "name": "excludedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "excludeSenders", - "inputs": [], - "outputs": [ - { - "name": "excludedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "setUp", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "simulateForkAndTransfer", - "inputs": [ - { - "name": "forkAtBlock", - "type": "uint256", - "internalType": "uint256" - }, - { - "name": "sender", - "type": "address", - "internalType": "address" - }, - { - "name": "receiver", - "type": "address", - "internalType": "address" - }, - { - "name": "amount", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "targetArtifactSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifactSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzArtifactSelector[]", - "components": [ - { - "name": "artifact", - "type": "string", - "internalType": "string" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetArtifacts", - "inputs": [], - "outputs": [ - { - "name": "targetedArtifacts_", - "type": "string[]", - "internalType": "string[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetContracts", - "inputs": [], - "outputs": [ - { - "name": "targetedContracts_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetInterfaces", - "inputs": [], - "outputs": [ - { - "name": "targetedInterfaces_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzInterface[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "artifacts", - "type": "string[]", - "internalType": "string[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSelectors", - "inputs": [], - "outputs": [ - { - "name": "targetedSelectors_", - "type": "tuple[]", - "internalType": "struct StdInvariant.FuzzSelector[]", - "components": [ - { - "name": "addr", - "type": "address", - "internalType": "address" - }, - { - "name": "selectors", - "type": "bytes4[]", - "internalType": "bytes4[]" - } - ] - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "targetSenders", - "inputs": [], - "outputs": [ - { - "name": "targetedSenders_", - "type": "address[]", - "internalType": "address[]" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "testSolvBTCStrategy", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "testSolvLSTStrategy", - "inputs": [], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "token", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "contract IERC20" - } - ], - "stateMutability": "view" - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_array", - "inputs": [ - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256[]", - "indexed": false, - "internalType": "uint256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256[]", - "indexed": false, - "internalType": "int256[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_array", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address[]", - "indexed": false, - "internalType": "address[]" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 SolvStrategyForked { - use super::*; - use alloy::sol_types as 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`\x0C\x80T`\x01`\xFF\x19\x91\x82\x16\x81\x17\x90\x92U`\x1F\x80T\x90\x91\x16\x90\x91\x17\x90U4\x80\x15`+W__\xFD[P`\x1F\x80Ta\x01\0`\x01`\xA8\x1B\x03\x19\x16t\x03\xC7\x05K\xCB9\xF7\xB2\xE5\xB2\xC7\xAC\xB3u\x83\xE3-p\xCF\xA3\0\x17\x90Ua5\xC6\x80a\0a_9_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\x01\x15W_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\xADW\x80c\xE2\x0C\x9Fq\x11a\0}W\x80c\xF9\xCE\x0EZ\x11a\0cW\x80c\xF9\xCE\x0EZ\x14a\x01\xE5W\x80c\xFAv&\xD4\x14a\x01\xF8W\x80c\xFC\x0CTj\x14a\x02\x05W__\xFD[\x80c\xE2\x0C\x9Fq\x14a\x01\xD5W\x80c\xF7\xF0\x8C\xFB\x14a\x01\xDDW__\xFD[\x80c\x91j\x17\xC6\x14a\x01\x98W\x80c\xB0FO\xDC\x14a\x01\xADW\x80c\xB5P\x8A\xA9\x14a\x01\xB5W\x80c\xBAAO\xA6\x14a\x01\xBDW__\xFD[\x80c?r\x86\xF4\x11a\0\xE8W\x80c?r\x86\xF4\x14a\x01^W\x80cf\xD9\xA9\xA0\x14a\x01fW\x80c~\xEC\x06\xB2\x14a\x01{W\x80c\x85\"l\x81\x14a\x01\x83W__\xFD[\x80c\n\x92T\xE4\x14a\x01\x19W\x80c\x1E\xD7\x83\x1C\x14a\x01#W\x80c*\xDE8\x80\x14a\x01AW\x80c>^<#\x14a\x01VW[__\xFD[a\x01!a\x025V[\0[a\x01+a\x02rV[`@Qa\x018\x91\x90a\x14\x8CV[`@Q\x80\x91\x03\x90\xF3[a\x01Ia\x02\xD2V[`@Qa\x018\x91\x90a\x15\x05V[a\x01+a\x04\x0EV[a\x01+a\x04lV[a\x01na\x04\xCAV[`@Qa\x018\x91\x90a\x16HV[a\x01!a\x06CV[a\x01\x8Ba\t\x94V[`@Qa\x018\x91\x90a\x16\xC6V[a\x01\xA0a\n_V[`@Qa\x018\x91\x90a\x17\x1DV[a\x01\xA0a\x0BUV[a\x01\x8Ba\x0CKV[a\x01\xC5a\r\x16V[`@Q\x90\x15\x15\x81R` \x01a\x018V[a\x01+a\r\xE6V[a\x01!a\x0EDV[a\x01!a\x01\xF36`\x04a\x17\xAFV[a\x11\xB3V[`\x1FTa\x01\xC5\x90`\xFF\x16\x81V[`\x1FTa\x02\x1D\x90a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x018V[a\x02pb\\\xBA\x95sZ\x8E\x97t\xD6\x7F\xE8F\xC6\xF41\x1C\x07>*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x11\xB3V[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xC8W` \x02\x82\x01\x91\x90_R` _ \x90[\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xAAW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x03\xEEW\x83\x82\x90_R` _ \x01\x80Ta\x03c\x90a\x17\xF0V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\x8F\x90a\x17\xF0V[\x80\x15a\x03\xDAW\x80`\x1F\x10a\x03\xB1Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xDAV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xBDW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03FV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xF5V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xC8W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xAAWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xC8W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xAAWPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x05\x1D\x90a\x17\xF0V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05I\x90a\x17\xF0V[\x80\x15a\x05\x94W\x80`\x1F\x10a\x05kWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05\x94V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05wW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06+W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x05\xD8W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x04\xEDV[_sT\x1F\xD7IA\x9C\xA8\x06\xA8\xBC}\xA8\xAC#\xD3F\xF2\xDF\x8Bw\x90P_sI\xB0r\x15\x85d\xDB60E\x18\xFF\xA3{\x1C\xFC\x13\x91j\x90\x7FVdR\x02@\xA4kK>\x96U\xC2\x0C\xC3\xF9\xE0\x84\x96\xA9\xB7F\xA4x\xE4v\xAE>\x04\xD6\xC8\xFC1\x83`@Qa\x06\x9F\x90a\x14rV[`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x81R` \x81\x01\x92\x90\x92R\x90\x91\x16`@\x82\x01R``\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x06\xD8W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07RW__\xFD[PZ\xF1\x15\x80\x15a\x07dW=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x07\xDAW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xFE\x91\x90a\x18AV[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\x85W__\xFD[PZ\xF1\x15\x80\x15a\x08\x97W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\xE7W__\xFD[PZ\xF1\x15\x80\x15a\x08\xF9W=__>=_\xFD[PP`@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\x81R`\x01`\x04\x82\x01Ra\t\x90\x92P`\x01`\x01`\xA0\x1B\x03\x85\x16\x91Pcp\xA0\x821\x90`$\x01[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\t^W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\x82\x91\x90a\x18gV[g\r\xE0\xB6\xB3\xA7d\0\0a\x13\xEFV[PPV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W\x83\x82\x90_R` _ \x01\x80Ta\t\xD4\x90a\x17\xF0V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n\0\x90a\x17\xF0V[\x80\x15a\nKW\x80`\x1F\x10a\n\"Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\nKV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\n.W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\t\xB7V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0B=W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\n\xEAW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\n\x82V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C3W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0B\xE0W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0BxV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W\x83\x82\x90_R` _ \x01\x80Ta\x0C\x8B\x90a\x17\xF0V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C\xB7\x90a\x17\xF0V[\x80\x15a\r\x02W\x80`\x1F\x10a\x0C\xD9Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\r\x02V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0C\xE5W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0CnV[`\x08T_\x90`\xFF\x16\x15a\r-WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\r\xBBW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\xDF\x91\x90a\x18gV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xC8W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xAAWPPPPP\x90P\x90V[_sT\x1F\xD7IA\x9C\xA8\x06\xA8\xBC}\xA8\xAC#\xD3F\xF2\xDF\x8Bw\x90P_s\xCC\tf\xD8A\x8DA,Y\x9Ad!\xB7`\xA8G\xEB\x16\x9A\x8C\x90P_sI\xB0r\x15\x85d\xDB60E\x18\xFF\xA3{\x1C\xFC\x13\x91j\x90s\xBAF\xFC\xC1kFM\x97\x871Ag\xBD\xD9\xF1\xCE(@[\xA1\x7FVdR\x02@\xA4kK>\x96U\xC2\x0C\xC3\xF9\xE0\x84\x96\xA9\xB7F\xA4x\xE4v\xAE>\x04\xD6\xC8\xFC1\x7Fh\x99\xA7\xE1;e_\xA3g \x8C\xB2|n\xAA$\x107\r\x15e\xDC\x1F_\x11\x85:\x1E\x8C\xBE\xF03\x86\x86`@Qa\x0E\xEF\x90a\x14\x7FV[`\x01`\x01`\xA0\x1B\x03\x96\x87\x16\x81R\x94\x86\x16` \x86\x01R`@\x85\x01\x93\x90\x93R``\x84\x01\x91\x90\x91R\x83\x16`\x80\x83\x01R\x90\x91\x16`\xA0\x82\x01R`\xC0\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x0F?W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0F\xB9W__\xFD[PZ\xF1\x15\x80\x15a\x0F\xCBW=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10AW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10e\x91\x90a\x18AV[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10\xECW__\xFD[PZ\xF1\x15\x80\x15a\x10\xFEW=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x11NW__\xFD[PZ\xF1\x15\x80\x15a\x11`W=__>=_\xFD[PP`@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\x81R`\x01`\x04\x82\x01Ra\x11\xAE\x92P`\x01`\x01`\xA0\x1B\x03\x85\x16\x91Pcp\xA0\x821\x90`$\x01a\tCV[PPPV[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x12NW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x12u\x91\x90\x81\x01\x90a\x18\xABV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x12\x93\x92\x91\x90a\x19_V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x12\xAFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xD3\x91\x90a\x18gV[P`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x13?W__\xFD[PZ\xF1\x15\x80\x15a\x13QW=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x13\xC4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13\xE8\x91\x90a\x18AV[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x14XW__\xFD[PZ\xFA\x15\x80\x15a\x14jW=__>=_\xFD[PPPPPPV[a\x0C\xE3\x80a\x19\x81\x839\x01\x90V[a\x0F-\x80a&d\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x14\xCCW\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x14\xA5V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\xE0W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`\x01`\x01`\xA0\x1B\x03\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x15\xC6W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x15\xB0\x84\x86Qa\x14\xD7V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x15vV[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x15+V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x16>W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x15\xFEV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\xE0W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x16\x94`@\x88\x01\x82a\x14\xD7V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x16\xAF\x81\x83a\x15\xECV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16nV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\xE0W`?\x19\x87\x86\x03\x01\x84Ra\x17\x08\x85\x83Qa\x14\xD7V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16\xECV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\xE0W`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x17~`@\x87\x01\x82a\x15\xECV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x17CV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x17\xAAW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x17\xC2W__\xFD[\x845\x93Pa\x17\xD2` \x86\x01a\x17\x94V[\x92Pa\x17\xE0`@\x86\x01a\x17\x94V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x18\x04W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x18;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`\"`\x04R`$_\xFD[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x18QW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x18`W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x18wW__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x18\xBBW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\xD1W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x18\xE1W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\xFBWa\x18\xFBa\x18~V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x19+Wa\x19+a\x18~V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x19BW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x19q`@\x83\x01\x85a\x14\xD7V[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xE0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x0C\xE38\x03\x80a\x0C\xE3\x839\x81\x01`@\x81\x90Ra\0.\x91a\0bV[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16`\x80R`\xA0\x91\x90\x91R\x16`\xC0Ra\0\xA2V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0_W__\xFD[PV[___``\x84\x86\x03\x12\x15a\0tW__\xFD[\x83Qa\0\x7F\x81a\0KV[` \x85\x01Q`@\x86\x01Q\x91\x94P\x92Pa\0\x97\x81a\0KV[\x80\x91PP\x92P\x92P\x92V[`\x80Q`\xA0Q`\xC0Qa\x0B\xF6a\0\xED_9_\x81\x81a\x01\x1B\x01R\x81\x81a\x03-\x01Ra\x03o\x01R_\x81\x81`\xBE\x01Ra\x01\xF2\x01R_\x81\x81`m\x01R\x81\x81a\x01\xA5\x01Ra\x02!\x01Ra\x0B\xF6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0dW_5`\xE0\x1C\x80cPcL\x0E\x11a\0MW\x80cPcL\x0E\x14a\0\xEEW\x80c\x7F\x81O5\x14a\x01\x03W\x80c\xB9\x93|\xCB\x14a\x01\x16W__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0hW\x80c>\r\xC3N\x14a\0\xB9W[__\xFD[a\0\x8F\x7F\0\0\0\0\0\0\0\0\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\xE0\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xB0V[a\x01\x01a\0\xFC6`\x04a\t\x97V[a\x01=V[\0[a\x01\x01a\x01\x116`\x04a\nYV[a\x01gV[a\0\x8F\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01R\x91\x90a\n\xDDV[\x90Pa\x01`\x85\x85\x85\x84a\x01gV[PPPPPV[a\x01\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x03\xCAV[a\x01\xCAs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\x8EV[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02|W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xA0\x91\x90a\x0B\x01V[\x82Q\x90\x91P\x81\x10\x15a\x03\x13W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03Ts\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\x84\x83a\x05\x89V[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\x88\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xE4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x02W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05&\x91\x90a\x0B\x01V[a\x050\x91\x90a\x0B\x18V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\x88\x90\x85\x90\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\x90`d\x01a\x04$V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x05\xDF\x90\x84\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\x90`d\x01a\x04$V[PPPV[_a\x06E\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\x06\xEF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x05\xDFW\x80\x80` \x01\x90Q\x81\x01\x90a\x06c\x91\x90a\x0BVV[a\x05\xDFW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[``a\x06\xFD\x84\x84_\x85a\x07\x07V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\x99W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\x17W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[__\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\x08?\x91\x90a\x0BuV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08yW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08~V[``\x91P[P\x91P\x91Pa\x08\x8E\x82\x82\x86a\x08\x99V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xA8WP\x81a\x07\0V[\x82Q\x15a\x08\xB8W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\n\x91\x90a\x0B\x8BV[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\t\rW__\xFD[PV[\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`Wa\t`a\t\x10V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\x8FWa\t\x8Fa\t\x10V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xAAW__\xFD[\x845a\t\xB5\x81a\x08\xECV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xCC\x81a\x08\xECV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xE7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\t\xF7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x11Wa\n\x11a\t\x10V[a\n$` `\x1F\x19`\x1F\x84\x01\x16\x01a\tfV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n8W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\nmW__\xFD[\x855a\nx\x81a\x08\xECV[\x94P` \x86\x015\x93P`@\x86\x015a\n\x8F\x81a\x08\xECV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xC0W__\xFD[Pa\n\xC9a\t=V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\n\xEEW__\xFD[Pa\n\xF7a\t=V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\x11W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0BPW\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[_` \x82\x84\x03\x12\x15a\x0BfW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\0W__\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\xFE\xA2dipfsX\"\x12 \xEA:\x8D\x8D\x03\xA7\x99\xDE\xBEZ\xF3\x80t\xA1\xC6S\x89f\xE8#\xECG\xA2\xDDfH\x1F<\x94\xF2SxdsolcC\0\x08\x1C\x003a\x01@`@R4\x80\x15a\0\x10W__\xFD[P`@Qa\x0F-8\x03\x80a\x0F-\x839\x81\x01`@\x81\x90Ra\0/\x91a\0sV[`\x01`\x01`\xA0\x1B\x03\x95\x86\x16`\x80R\x93\x85\x16`\xA0R`\xC0\x92\x90\x92R`\xE0R\x82\x16a\x01\0R\x16a\x01 Ra\0\xE3V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0pW__\xFD[PV[______`\xC0\x87\x89\x03\x12\x15a\0\x88W__\xFD[\x86Qa\0\x93\x81a\0\\V[` \x88\x01Q\x90\x96Pa\0\xA4\x81a\0\\V[`@\x88\x01Q``\x89\x01Q`\x80\x8A\x01Q\x92\x97P\x90\x95P\x93Pa\0\xC4\x81a\0\\V[`\xA0\x88\x01Q\x90\x92Pa\0\xD5\x81a\0\\V[\x80\x91PP\x92\x95P\x92\x95P\x92\x95V[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\r\xC6a\x01g_9_\x81\x81a\x01.\x01R\x81\x81a\x04\xFC\x01Ra\x05>\x01R_\x81\x81a\x01U\x01Ra\x03R\x01R_\x81\x81a\x01\xB1\x01Ra\x03\xC1\x01R_\x81\x81a\x01|\x01Ra\x02\x88\x01R_\x81\x81`\xDF\x01R\x81\x81a\x03t\x01Ra\x03\xF0\x01R_\x81\x81`\x8E\x01R\x81\x81a\x02;\x01Ra\x02\xB7\x01Ra\r\xC6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\x85W_5`\xE0\x1C\x80c\xADt}\xE6\x11a\0XW\x80c\xADt}\xE6\x14a\x01)W\x80c\xB9\x93|\xCB\x14a\x01PW\x80c\xC8\xC7\xF7\x01\x14a\x01wW\x80c\xE3L\xEF\x86\x14a\x01\xACW__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0\x89W\x80cN=\xF3\xF4\x14a\0\xDAW\x80cPcL\x0E\x14a\x01\x01W\x80c\x7F\x81O5\x14a\x01\x16W[__\xFD[a\0\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\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\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\x81V[a\x01\x14a\x01\x0F6`\x04a\x0BgV[a\x01\xD3V[\0[a\x01\x14a\x01$6`\x04a\x0C)V[a\x01\xFDV[a\0\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\x81V[a\0\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\x81V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xD1V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\xE8\x91\x90a\x0C\xADV[\x90Pa\x01\xF6\x85\x85\x85\x84a\x01\xFDV[PPPPPV[a\x02\x1Fs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x9AV[a\x02`s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x036\x91\x90a\x0C\xD1V[\x90Pa\x03\x99s\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\x7F\0\0\0\0\0\0\0\0\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\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x82\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04KW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04o\x91\x90a\x0C\xD1V[\x83Q\x90\x91P\x81\x10\x15a\x04\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[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\x85\x83a\x07YV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x06X\x90\x85\x90\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\x90`\x84\x01[`@\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\x07\xB4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF6\x91\x90a\x0C\xD1V[a\x07\0\x91\x90a\x0C\xE8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x06X\x90\x85\x90\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\x90`d\x01a\x05\xF4V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07\xAF\x90\x84\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\x90`d\x01a\x05\xF4V[PPPV[_a\x08\x15\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\x08\xBF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\xAFW\x80\x80` \x01\x90Q\x81\x01\x90a\x083\x91\x90a\r&V[a\x07\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\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\x04\xD9V[``a\x08\xCD\x84\x84_\x85a\x08\xD7V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\tiW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x04\xD9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\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`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x04\xD9V[__\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\n\x0F\x91\x90a\rEV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\nIW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\nNV[``\x91P[P\x91P\x91Pa\n^\x82\x82\x86a\niV[\x97\x96PPPPPPPV[``\x83\x15a\nxWP\x81a\x08\xD0V[\x82Q\x15a\n\x88W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x04\xD9\x91\x90a\r[V[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\xDDW__\xFD[PV[\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\x0B0Wa\x0B0a\n\xE0V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0B_Wa\x0B_a\n\xE0V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0BzW__\xFD[\x845a\x0B\x85\x81a\n\xBCV[\x93P` \x85\x015\x92P`@\x85\x015a\x0B\x9C\x81a\n\xBCV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xB7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\x0B\xC7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xE1Wa\x0B\xE1a\n\xE0V[a\x0B\xF4` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0B6V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0C\x08W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0C=W__\xFD[\x855a\x0CH\x81a\n\xBCV[\x94P` \x86\x015\x93P`@\x86\x015a\x0C_\x81a\n\xBCV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0C\x90W__\xFD[Pa\x0C\x99a\x0B\rV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0C\xBEW__\xFD[Pa\x0C\xC7a\x0B\rV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C\xE1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\r 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[_` \x82\x84\x03\x12\x15a\r6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x08\xD0W__\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\xFE\xA2dipfsX\"\x12 \xD28\x8C\xB3\xDCz\xA6\xF5\xA2\xEBuA}\x11\x05\x9B\xE1<\x8C\x9E\xAB\xE5\xD7\xEA\xDB\x1BV\x1F\x93\x7F\xF6\x91dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 \xBE\xBAcC7\xF2ib\xD3\xA2*^\xDC\x8C)\xAE\xFEz\xB3T\x85\xB7\x1D<\xCC\x01\xFB\xE1.[\xEF\xF6dsolcC\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\x01\x15W_5`\xE0\x1C\x80c\x91j\x17\xC6\x11a\0\xADW\x80c\xE2\x0C\x9Fq\x11a\0}W\x80c\xF9\xCE\x0EZ\x11a\0cW\x80c\xF9\xCE\x0EZ\x14a\x01\xE5W\x80c\xFAv&\xD4\x14a\x01\xF8W\x80c\xFC\x0CTj\x14a\x02\x05W__\xFD[\x80c\xE2\x0C\x9Fq\x14a\x01\xD5W\x80c\xF7\xF0\x8C\xFB\x14a\x01\xDDW__\xFD[\x80c\x91j\x17\xC6\x14a\x01\x98W\x80c\xB0FO\xDC\x14a\x01\xADW\x80c\xB5P\x8A\xA9\x14a\x01\xB5W\x80c\xBAAO\xA6\x14a\x01\xBDW__\xFD[\x80c?r\x86\xF4\x11a\0\xE8W\x80c?r\x86\xF4\x14a\x01^W\x80cf\xD9\xA9\xA0\x14a\x01fW\x80c~\xEC\x06\xB2\x14a\x01{W\x80c\x85\"l\x81\x14a\x01\x83W__\xFD[\x80c\n\x92T\xE4\x14a\x01\x19W\x80c\x1E\xD7\x83\x1C\x14a\x01#W\x80c*\xDE8\x80\x14a\x01AW\x80c>^<#\x14a\x01VW[__\xFD[a\x01!a\x025V[\0[a\x01+a\x02rV[`@Qa\x018\x91\x90a\x14\x8CV[`@Q\x80\x91\x03\x90\xF3[a\x01Ia\x02\xD2V[`@Qa\x018\x91\x90a\x15\x05V[a\x01+a\x04\x0EV[a\x01+a\x04lV[a\x01na\x04\xCAV[`@Qa\x018\x91\x90a\x16HV[a\x01!a\x06CV[a\x01\x8Ba\t\x94V[`@Qa\x018\x91\x90a\x16\xC6V[a\x01\xA0a\n_V[`@Qa\x018\x91\x90a\x17\x1DV[a\x01\xA0a\x0BUV[a\x01\x8Ba\x0CKV[a\x01\xC5a\r\x16V[`@Q\x90\x15\x15\x81R` \x01a\x018V[a\x01+a\r\xE6V[a\x01!a\x0EDV[a\x01!a\x01\xF36`\x04a\x17\xAFV[a\x11\xB3V[`\x1FTa\x01\xC5\x90`\xFF\x16\x81V[`\x1FTa\x02\x1D\x90a\x01\0\x90\x04`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x018V[a\x02pb\\\xBA\x95sZ\x8E\x97t\xD6\x7F\xE8F\xC6\xF41\x1C\x07>*\xC3K3dos\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8Ec\x05\xF5\xE1\0a\x11\xB3V[V[```\x16\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xC8W` \x02\x82\x01\x91\x90_R` _ \x90[\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xAAW[PPPPP\x90P\x90V[```\x1E\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W_\x84\x81R` \x80\x82 `@\x80Q\x80\x82\x01\x82R`\x02\x87\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x95\x91\x94\x86\x81\x01\x94\x91\x92\x90\x84\x01[\x82\x82\x10\x15a\x03\xEEW\x83\x82\x90_R` _ \x01\x80Ta\x03c\x90a\x17\xF0V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x03\x8F\x90a\x17\xF0V[\x80\x15a\x03\xDAW\x80`\x1F\x10a\x03\xB1Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x03\xDAV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x03\xBDW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x03FV[PPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x02\xF5V[PPPP\x90P\x90V[```\x18\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xC8W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xAAWPPPPP\x90P\x90V[```\x17\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xC8W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xAAWPPPPP\x90P\x90V[```\x1B\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W\x83\x82\x90_R` _ \x90`\x02\x02\x01`@Q\x80`@\x01`@R\x90\x81_\x82\x01\x80Ta\x05\x1D\x90a\x17\xF0V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x05I\x90a\x17\xF0V[\x80\x15a\x05\x94W\x80`\x1F\x10a\x05kWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x05\x94V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x05wW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01`\x01\x82\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x06+W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x05\xD8W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x04\xEDV[_sT\x1F\xD7IA\x9C\xA8\x06\xA8\xBC}\xA8\xAC#\xD3F\xF2\xDF\x8Bw\x90P_sI\xB0r\x15\x85d\xDB60E\x18\xFF\xA3{\x1C\xFC\x13\x91j\x90\x7FVdR\x02@\xA4kK>\x96U\xC2\x0C\xC3\xF9\xE0\x84\x96\xA9\xB7F\xA4x\xE4v\xAE>\x04\xD6\xC8\xFC1\x83`@Qa\x06\x9F\x90a\x14rV[`\x01`\x01`\xA0\x1B\x03\x93\x84\x16\x81R` \x81\x01\x92\x90\x92R\x90\x91\x16`@\x82\x01R``\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x06\xD8W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x07RW__\xFD[PZ\xF1\x15\x80\x15a\x07dW=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x07\xDAW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xFE\x91\x90a\x18AV[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\x85W__\xFD[PZ\xF1\x15\x80\x15a\x08\x97W=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x08\xE7W__\xFD[PZ\xF1\x15\x80\x15a\x08\xF9W=__>=_\xFD[PP`@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\x81R`\x01`\x04\x82\x01Ra\t\x90\x92P`\x01`\x01`\xA0\x1B\x03\x85\x16\x91Pcp\xA0\x821\x90`$\x01[` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\t^W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\t\x82\x91\x90a\x18gV[g\r\xE0\xB6\xB3\xA7d\0\0a\x13\xEFV[PPV[```\x1A\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W\x83\x82\x90_R` _ \x01\x80Ta\t\xD4\x90a\x17\xF0V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\n\0\x90a\x17\xF0V[\x80\x15a\nKW\x80`\x1F\x10a\n\"Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\nKV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\n.W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\t\xB7V[```\x1D\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0B=W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\n\xEAW\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\n\x82V[```\x1C\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W_\x84\x81R` \x90\x81\x90 `@\x80Q\x80\x82\x01\x82R`\x02\x86\x02\x90\x92\x01\x80T`\x01`\x01`\xA0\x1B\x03\x16\x83R`\x01\x81\x01\x80T\x83Q\x81\x87\x02\x81\x01\x87\x01\x90\x94R\x80\x84R\x93\x94\x91\x93\x85\x83\x01\x93\x92\x83\x01\x82\x82\x80\x15a\x0C3W` \x02\x82\x01\x91\x90_R` _ \x90_\x90[\x82\x82\x90T\x90a\x01\0\n\x90\x04`\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\x81R` \x01\x90`\x04\x01\x90` \x82`\x03\x01\x04\x92\x83\x01\x92`\x01\x03\x82\x02\x91P\x80\x84\x11a\x0B\xE0W\x90P[PPPPP\x81RPP\x81R` \x01\x90`\x01\x01\x90a\x0BxV[```\x19\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01_\x90[\x82\x82\x10\x15a\x04\x05W\x83\x82\x90_R` _ \x01\x80Ta\x0C\x8B\x90a\x17\xF0V[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x0C\xB7\x90a\x17\xF0V[\x80\x15a\r\x02W\x80`\x1F\x10a\x0C\xD9Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\r\x02V[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x0C\xE5W\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81R` \x01\x90`\x01\x01\x90a\x0CnV[`\x08T_\x90`\xFF\x16\x15a\r-WP`\x08T`\xFF\x16\x90V[`@Q\x7Ff\x7F\x9Dp\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x04\x82\x01\x81\x90R\x7Ffailed\0\0\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\x01R_\x91cf\x7F\x9Dp\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\r\xBBW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\r\xDF\x91\x90a\x18gV[\x14\x15\x90P\x90V[```\x15\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\x02\xC8W` \x02\x82\x01\x91\x90_R` _ \x90\x81T`\x01`\x01`\xA0\x1B\x03\x16\x81R`\x01\x90\x91\x01\x90` \x01\x80\x83\x11a\x02\xAAWPPPPP\x90P\x90V[_sT\x1F\xD7IA\x9C\xA8\x06\xA8\xBC}\xA8\xAC#\xD3F\xF2\xDF\x8Bw\x90P_s\xCC\tf\xD8A\x8DA,Y\x9Ad!\xB7`\xA8G\xEB\x16\x9A\x8C\x90P_sI\xB0r\x15\x85d\xDB60E\x18\xFF\xA3{\x1C\xFC\x13\x91j\x90s\xBAF\xFC\xC1kFM\x97\x871Ag\xBD\xD9\xF1\xCE(@[\xA1\x7FVdR\x02@\xA4kK>\x96U\xC2\x0C\xC3\xF9\xE0\x84\x96\xA9\xB7F\xA4x\xE4v\xAE>\x04\xD6\xC8\xFC1\x7Fh\x99\xA7\xE1;e_\xA3g \x8C\xB2|n\xAA$\x107\r\x15e\xDC\x1F_\x11\x85:\x1E\x8C\xBE\xF03\x86\x86`@Qa\x0E\xEF\x90a\x14\x7FV[`\x01`\x01`\xA0\x1B\x03\x96\x87\x16\x81R\x94\x86\x16` \x86\x01R`@\x85\x01\x93\x90\x93R``\x84\x01\x91\x90\x91R\x83\x16`\x80\x83\x01R\x90\x91\x16`\xA0\x82\x01R`\xC0\x01`@Q\x80\x91\x03\x90_\xF0\x80\x15\x80\x15a\x0F?W=__>=_\xFD[P`@Q\x7F\x06D}V\0\0\0\0\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\x99\x99\x99\xCF\x10F\xE6\x8E6\xE1\xAA.\x0E\x07\x10^\xDD\xD1\xF0\x8E`\x04\x82\x01R\x90\x91Psq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x06D}V\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x0F\xB9W__\xFD[PZ\xF1\x15\x80\x15a\x0F\xCBW=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x85\x81\x16`\x04\x83\x01Rc\x05\xF5\xE1\0`$\x83\x01Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\t^\xA7\xB3\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x10AW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x10e\x91\x90a\x18AV[P`\x1FT`@\x80Q` \x81\x01\x82R_\x81R\x90Q\x7F\x7F\x81O5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81Ra\x01\0\x90\x92\x04`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\x04\x84\x01Rc\x05\xF5\xE1\0`$\x84\x01R`\x01`D\x84\x01R\x90Q`d\x83\x01R\x82\x16\x90c\x7F\x81O5\x90`\x84\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x10\xECW__\xFD[PZ\xF1\x15\x80\x15a\x10\xFEW=__>=_\xFD[PPPPsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x01`\x01`\xA0\x1B\x03\x16c\x90\xC5\x01;`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x11NW__\xFD[PZ\xF1\x15\x80\x15a\x11`W=__>=_\xFD[PP`@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\x81R`\x01`\x04\x82\x01Ra\x11\xAE\x92P`\x01`\x01`\xA0\x1B\x03\x85\x16\x91Pcp\xA0\x821\x90`$\x01a\tCV[PPPV[`@Q\x7F\xF8w\xCB\x19\0\0\0\0\0\0\0\0\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\x7FBOB_PROD_PUBLIC_RPC_URL\0\0\0\0\0\0\0\0\0`D\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90cq\xEEFM\x90\x82\x90c\xF8w\xCB\x19\x90`d\x01_`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x12NW=__>=_\xFD[PPPP`@Q=_\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x12u\x91\x90\x81\x01\x90a\x18\xABV[\x86`@Q\x83c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01a\x12\x93\x92\x91\x90a\x19_V[` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x12\xAFW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x12\xD3\x91\x90a\x18gV[P`@Q\x7F\xCAf\x9F\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\x81R`\x01`\x01`\xA0\x1B\x03\x84\x16`\x04\x82\x01Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\xCAf\x9F\xA7\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x13?W__\xFD[PZ\xF1\x15\x80\x15a\x13QW=__>=_\xFD[PP`\x1FT`@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\x81R`\x01`\x01`\xA0\x1B\x03\x86\x81\x16`\x04\x83\x01R`$\x82\x01\x86\x90Ra\x01\0\x90\x92\x04\x90\x91\x16\x92Pc\xA9\x05\x9C\xBB\x91P`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x13\xC4W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x13\xE8\x91\x90a\x18AV[PPPPPV[`@Q\x7F\x98)lT\0\0\0\0\0\0\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\x83\x90R`$\x81\x01\x82\x90Rsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-\x90c\x98)lT\x90`D\x01_`@Q\x80\x83\x03\x81\x86\x80;\x15\x80\x15a\x14XW__\xFD[PZ\xFA\x15\x80\x15a\x14jW=__>=_\xFD[PPPPPPV[a\x0C\xE3\x80a\x19\x81\x839\x01\x90V[a\x0F-\x80a&d\x839\x01\x90V[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x14\xCCW\x83Q`\x01`\x01`\xA0\x1B\x03\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x14\xA5V[P\x90\x95\x94PPPPPV[_\x81Q\x80\x84R\x80` \x84\x01` \x86\x01^_` \x82\x86\x01\x01R` `\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x91PP\x92\x91PPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\xE0W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`\x01`\x01`\xA0\x1B\x03\x16\x86R` \x90\x81\x01Q`@\x82\x88\x01\x81\x90R\x81Q\x90\x88\x01\x81\x90R\x91\x01\x90```\x05\x82\x90\x1B\x88\x01\x81\x01\x91\x90\x88\x01\x90_[\x81\x81\x10\x15a\x15\xC6W\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x8A\x85\x03\x01\x83Ra\x15\xB0\x84\x86Qa\x14\xD7V[` \x95\x86\x01\x95\x90\x94P\x92\x90\x92\x01\x91`\x01\x01a\x15vV[P\x91\x97PPP` \x94\x85\x01\x94\x92\x90\x92\x01\x91P`\x01\x01a\x15+V[P\x92\x96\x95PPPPPPV[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x16>W\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\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x15\xFEV[P\x93\x94\x93PPPPV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\xE0W`?\x19\x87\x86\x03\x01\x84R\x81Q\x80Q`@\x87Ra\x16\x94`@\x88\x01\x82a\x14\xD7V[\x90P` \x82\x01Q\x91P\x86\x81\x03` \x88\x01Ra\x16\xAF\x81\x83a\x15\xECV[\x96PPP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16nV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\xE0W`?\x19\x87\x86\x03\x01\x84Ra\x17\x08\x85\x83Qa\x14\xD7V[\x94P` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x16\xECV[_` \x82\x01` \x83R\x80\x84Q\x80\x83R`@\x85\x01\x91P`@\x81`\x05\x1B\x86\x01\x01\x92P` \x86\x01_[\x82\x81\x10\x15a\x15\xE0W`?\x19\x87\x86\x03\x01\x84R\x81Q`\x01`\x01`\xA0\x1B\x03\x81Q\x16\x86R` \x81\x01Q\x90P`@` \x87\x01Ra\x17~`@\x87\x01\x82a\x15\xECV[\x95PP` \x93\x84\x01\x93\x91\x90\x91\x01\x90`\x01\x01a\x17CV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x17\xAAW__\xFD[\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x17\xC2W__\xFD[\x845\x93Pa\x17\xD2` \x86\x01a\x17\x94V[\x92Pa\x17\xE0`@\x86\x01a\x17\x94V[\x93\x96\x92\x95P\x92\x93``\x015\x92PPV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x18\x04W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x18;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`\"`\x04R`$_\xFD[P\x91\x90PV[_` \x82\x84\x03\x12\x15a\x18QW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x18`W__\xFD[\x93\x92PPPV[_` \x82\x84\x03\x12\x15a\x18wW__\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x18\xBBW__\xFD[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\xD1W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x18\xE1W__\xFD[\x80Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x18\xFBWa\x18\xFBa\x18~V[`@Q`\x1F\x19`?`\x1F\x19`\x1F\x85\x01\x16\x01\x16\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x19+Wa\x19+a\x18~V[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x19BW__\xFD[\x81` \x84\x01` \x83\x01^_\x91\x81\x01` \x01\x91\x90\x91R\x94\x93PPPPV[`@\x81R_a\x19q`@\x83\x01\x85a\x14\xD7V[\x90P\x82` \x83\x01R\x93\x92PPPV\xFE`\xE0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x0C\xE38\x03\x80a\x0C\xE3\x839\x81\x01`@\x81\x90Ra\0.\x91a\0bV[`\x01`\x01`\xA0\x1B\x03\x92\x83\x16`\x80R`\xA0\x91\x90\x91R\x16`\xC0Ra\0\xA2V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0_W__\xFD[PV[___``\x84\x86\x03\x12\x15a\0tW__\xFD[\x83Qa\0\x7F\x81a\0KV[` \x85\x01Q`@\x86\x01Q\x91\x94P\x92Pa\0\x97\x81a\0KV[\x80\x91PP\x92P\x92P\x92V[`\x80Q`\xA0Q`\xC0Qa\x0B\xF6a\0\xED_9_\x81\x81a\x01\x1B\x01R\x81\x81a\x03-\x01Ra\x03o\x01R_\x81\x81`\xBE\x01Ra\x01\xF2\x01R_\x81\x81`m\x01R\x81\x81a\x01\xA5\x01Ra\x02!\x01Ra\x0B\xF6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0dW_5`\xE0\x1C\x80cPcL\x0E\x11a\0MW\x80cPcL\x0E\x14a\0\xEEW\x80c\x7F\x81O5\x14a\x01\x03W\x80c\xB9\x93|\xCB\x14a\x01\x16W__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0hW\x80c>\r\xC3N\x14a\0\xB9W[__\xFD[a\0\x8F\x7F\0\0\0\0\0\0\0\0\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\xE0\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xB0V[a\x01\x01a\0\xFC6`\x04a\t\x97V[a\x01=V[\0[a\x01\x01a\x01\x116`\x04a\nYV[a\x01gV[a\0\x8F\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01R\x91\x90a\n\xDDV[\x90Pa\x01`\x85\x85\x85\x84a\x01gV[PPPPPV[a\x01\x89s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x03\xCAV[a\x01\xCAs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x04\x8EV[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x02|W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x02\xA0\x91\x90a\x0B\x01V[\x82Q\x90\x91P\x81\x10\x15a\x03\x13W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x03Ts\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\x84\x83a\x05\x89V[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x04\x88\x90\x85\x90\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\x90`\x84\x01[`@\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\x05\xE4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\x02W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05&\x91\x90a\x0B\x01V[a\x050\x91\x90a\x0B\x18V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x04\x88\x90\x85\x90\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\x90`d\x01a\x04$V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x05\xDF\x90\x84\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\x90`d\x01a\x04$V[PPPV[_a\x06E\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\x06\xEF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x05\xDFW\x80\x80` \x01\x90Q\x81\x01\x90a\x06c\x91\x90a\x0BVV[a\x05\xDFW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[``a\x06\xFD\x84\x84_\x85a\x07\x07V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\x07\x99W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\x08\x17W`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x03\nV[__\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\x08?\x91\x90a\x0BuV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\x08yW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x08~V[``\x91P[P\x91P\x91Pa\x08\x8E\x82\x82\x86a\x08\x99V[\x97\x96PPPPPPPV[``\x83\x15a\x08\xA8WP\x81a\x07\0V[\x82Q\x15a\x08\xB8W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x03\n\x91\x90a\x0B\x8BV[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\t\rW__\xFD[PV[\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`Wa\t`a\t\x10V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\t\x8FWa\t\x8Fa\t\x10V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\t\xAAW__\xFD[\x845a\t\xB5\x81a\x08\xECV[\x93P` \x85\x015\x92P`@\x85\x015a\t\xCC\x81a\x08\xECV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\t\xE7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\t\xF7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\n\x11Wa\n\x11a\t\x10V[a\n$` `\x1F\x19`\x1F\x84\x01\x16\x01a\tfV[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\n8W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\nmW__\xFD[\x855a\nx\x81a\x08\xECV[\x94P` \x86\x015\x93P`@\x86\x015a\n\x8F\x81a\x08\xECV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\n\xC0W__\xFD[Pa\n\xC9a\t=V[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\n\xEEW__\xFD[Pa\n\xF7a\t=V[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0B\x11W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\x0BPW\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[_` \x82\x84\x03\x12\x15a\x0BfW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x07\0W__\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\xFE\xA2dipfsX\"\x12 \xEA:\x8D\x8D\x03\xA7\x99\xDE\xBEZ\xF3\x80t\xA1\xC6S\x89f\xE8#\xECG\xA2\xDDfH\x1F<\x94\xF2SxdsolcC\0\x08\x1C\x003a\x01@`@R4\x80\x15a\0\x10W__\xFD[P`@Qa\x0F-8\x03\x80a\x0F-\x839\x81\x01`@\x81\x90Ra\0/\x91a\0sV[`\x01`\x01`\xA0\x1B\x03\x95\x86\x16`\x80R\x93\x85\x16`\xA0R`\xC0\x92\x90\x92R`\xE0R\x82\x16a\x01\0R\x16a\x01 Ra\0\xE3V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0pW__\xFD[PV[______`\xC0\x87\x89\x03\x12\x15a\0\x88W__\xFD[\x86Qa\0\x93\x81a\0\\V[` \x88\x01Q\x90\x96Pa\0\xA4\x81a\0\\V[`@\x88\x01Q``\x89\x01Q`\x80\x8A\x01Q\x92\x97P\x90\x95P\x93Pa\0\xC4\x81a\0\\V[`\xA0\x88\x01Q\x90\x92Pa\0\xD5\x81a\0\\V[\x80\x91PP\x92\x95P\x92\x95P\x92\x95V[`\x80Q`\xA0Q`\xC0Q`\xE0Qa\x01\0Qa\x01 Qa\r\xC6a\x01g_9_\x81\x81a\x01.\x01R\x81\x81a\x04\xFC\x01Ra\x05>\x01R_\x81\x81a\x01U\x01Ra\x03R\x01R_\x81\x81a\x01\xB1\x01Ra\x03\xC1\x01R_\x81\x81a\x01|\x01Ra\x02\x88\x01R_\x81\x81`\xDF\x01R\x81\x81a\x03t\x01Ra\x03\xF0\x01R_\x81\x81`\x8E\x01R\x81\x81a\x02;\x01Ra\x02\xB7\x01Ra\r\xC6_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\x85W_5`\xE0\x1C\x80c\xADt}\xE6\x11a\0XW\x80c\xADt}\xE6\x14a\x01)W\x80c\xB9\x93|\xCB\x14a\x01PW\x80c\xC8\xC7\xF7\x01\x14a\x01wW\x80c\xE3L\xEF\x86\x14a\x01\xACW__\xFD[\x80c\x06\xAF\x01\x9A\x14a\0\x89W\x80cN=\xF3\xF4\x14a\0\xDAW\x80cPcL\x0E\x14a\x01\x01W\x80c\x7F\x81O5\x14a\x01\x16W[__\xFD[a\0\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\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\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\x81V[a\x01\x14a\x01\x0F6`\x04a\x0BgV[a\x01\xD3V[\0[a\x01\x14a\x01$6`\x04a\x0C)V[a\x01\xFDV[a\0\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\x81V[a\0\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\x81V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x90\x81R` \x01a\0\xD1V[a\x01\x9E\x7F\0\0\0\0\0\0\0\0\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\x80` \x01\x90Q\x81\x01\x90a\x01\xE8\x91\x90a\x0C\xADV[\x90Pa\x01\xF6\x85\x85\x85\x84a\x01\xFDV[PPPPPV[a\x02\x1Fs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x1630\x86a\x05\x9AV[a\x02`s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\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\0\x85a\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x84\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x03\x12W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x036\x91\x90a\x0C\xD1V[\x90Pa\x03\x99s\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\x7F\0\0\0\0\0\0\0\0\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\x06^V[`@Q\x7FmrN\xAD\0\0\0\0\0\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`\x04\x82\x01R`$\x81\x01\x82\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\x90cmrN\xAD\x90`D\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x04KW=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04o\x91\x90a\x0C\xD1V[\x83Q\x90\x91P\x81\x10\x15a\x04\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\x82\x01R`\x1A`$\x82\x01R\x7FInsufficient output amount\0\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[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\x85\x83a\x07YV[`@\x80Qs\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\x81R` \x81\x01\x83\x90R\x7F\x0C}\xC5\xACy\x99\xDC\xAFC\xE1^[\xE6\xEBZ^*\xE4&\x84\r\xF3\x01\xCA\x0Bdc\xA6\xD7\x97\x98\x8D\x91\x01`@Q\x80\x91\x03\x90\xA1PPPPPPV[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x85\x16`$\x83\x01R\x83\x16`D\x82\x01R`d\x81\x01\x82\x90Ra\x06X\x90\x85\x90\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\x90`\x84\x01[`@\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\x07\xB4V[PPPPV[`@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\x83\x91\x86\x16\x90c\xDDb\xED>\x90`D\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD2W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF6\x91\x90a\x0C\xD1V[a\x07\0\x91\x90a\x0C\xE8V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16`$\x82\x01R`D\x81\x01\x82\x90R\x90\x91Pa\x06X\x90\x85\x90\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\x90`d\x01a\x05\xF4V[`@Qs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x16`$\x82\x01R`D\x81\x01\x82\x90Ra\x07\xAF\x90\x84\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\x90`d\x01a\x05\xF4V[PPPV[_a\x08\x15\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\x08\xBF\x90\x92\x91\x90c\xFF\xFF\xFF\xFF\x16V[\x80Q\x90\x91P\x15a\x07\xAFW\x80\x80` \x01\x90Q\x81\x01\x90a\x083\x91\x90a\r&V[a\x07\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\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\x04\xD9V[``a\x08\xCD\x84\x84_\x85a\x08\xD7V[\x90P[\x93\x92PPPV[``\x82G\x10\x15a\tiW`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\0\0\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\x04\xD9V[s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x85\x16;a\t\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`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01a\x04\xD9V[__\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\n\x0F\x91\x90a\rEV[_`@Q\x80\x83\x03\x81\x85\x87Z\xF1\x92PPP=\x80_\x81\x14a\nIW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\nNV[``\x91P[P\x91P\x91Pa\n^\x82\x82\x86a\niV[\x97\x96PPPPPPPV[``\x83\x15a\nxWP\x81a\x08\xD0V[\x82Q\x15a\n\x88W\x82Q\x80\x84` \x01\xFD[\x81`@Q\x7F\x08\xC3y\xA0\0\0\0\0\0\0\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\x04\xD9\x91\x90a\r[V[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\xDDW__\xFD[PV[\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\x0B0Wa\x0B0a\n\xE0V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x0B_Wa\x0B_a\n\xE0V[`@R\x91\x90PV[____`\x80\x85\x87\x03\x12\x15a\x0BzW__\xFD[\x845a\x0B\x85\x81a\n\xBCV[\x93P` \x85\x015\x92P`@\x85\x015a\x0B\x9C\x81a\n\xBCV[\x91P``\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xB7W__\xFD[\x85\x01`\x1F\x81\x01\x87\x13a\x0B\xC7W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0B\xE1Wa\x0B\xE1a\n\xE0V[a\x0B\xF4` `\x1F\x19`\x1F\x84\x01\x16\x01a\x0B6V[\x81\x81R\x88` \x83\x85\x01\x01\x11\x15a\x0C\x08W__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92\x95\x91\x94P\x92PV[____\x84\x86\x03`\x80\x81\x12\x15a\x0C=W__\xFD[\x855a\x0CH\x81a\n\xBCV[\x94P` \x86\x015\x93P`@\x86\x015a\x0C_\x81a\n\xBCV[\x92P` \x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xA0\x82\x01\x12\x15a\x0C\x90W__\xFD[Pa\x0C\x99a\x0B\rV[``\x95\x90\x95\x015\x85RP\x91\x94\x90\x93P\x90\x91\x90V[_` \x82\x84\x03\x12\x80\x15a\x0C\xBEW__\xFD[Pa\x0C\xC7a\x0B\rV[\x91Q\x82RP\x91\x90PV[_` \x82\x84\x03\x12\x15a\x0C\xE1W__\xFD[PQ\x91\x90PV[\x80\x82\x01\x80\x82\x11\x15a\r 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[_` \x82\x84\x03\x12\x15a\r6W__\xFD[\x81Q\x80\x15\x15\x81\x14a\x08\xD0W__\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\xFE\xA2dipfsX\"\x12 \xD28\x8C\xB3\xDCz\xA6\xF5\xA2\xEBuA}\x11\x05\x9B\xE1<\x8C\x9E\xAB\xE5\xD7\xEA\xDB\x1BV\x1F\x93\x7F\xF6\x91dsolcC\0\x08\x1C\x003\xA2dipfsX\"\x12 \xBE\xBAcC7\xF2ib\xD3\xA2*^\xDC\x8C)\xAE\xFEz\xB3T\x85\xB7\x1D<\xCC\x01\xFB\xE1.[\xEF\xF6dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. -```solidity -event log(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(uint256[])` and selector `0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1`. -```solidity -event log_array(uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_0 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(int256[])` and selector `0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5`. -```solidity -event log_array(int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_1 { - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_array(address[])` and selector `0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2`. -```solidity -event log_array(address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_array_2 { - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_array(address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { val: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,uint256[])` and selector `0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb`. -```solidity -event log_named_array(string key, uint256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_0 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_0 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,uint256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_0 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_0> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_0) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,int256[])` and selector `0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57`. -```solidity -event log_named_array(string key, int256[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_1 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_1 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,int256[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - , - > as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_1 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_1> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_1) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_array(string,address[])` and selector `0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd`. -```solidity -event log_named_array(string key, address[] val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_array_2 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_array_2 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Array, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_array(string,address[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_array_2 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_array_2> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_array_2) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeArtifacts()` and selector `0xb5508aa9`. -```solidity -function excludeArtifacts() external view returns (string[] memory excludedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeArtifacts()`](excludeArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeArtifactsReturn { - #[allow(missing_docs)] - pub excludedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeArtifactsReturn) -> Self { - (value.excludedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeArtifacts()"; - const SELECTOR: [u8; 4] = [181u8, 80u8, 138u8, 169u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeArtifactsReturn = r.into(); - r.excludedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeContracts()` and selector `0xe20c9f71`. -```solidity -function excludeContracts() external view returns (address[] memory excludedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeContracts()`](excludeContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeContractsReturn { - #[allow(missing_docs)] - pub excludedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeContractsReturn) -> Self { - (value.excludedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeContracts()"; - const SELECTOR: [u8; 4] = [226u8, 12u8, 159u8, 113u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeContractsReturn = r.into(); - r.excludedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSelectors()` and selector `0xb0464fdc`. -```solidity -function excludeSelectors() external view returns (StdInvariant.FuzzSelector[] memory excludedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSelectors()`](excludeSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSelectorsReturn { - #[allow(missing_docs)] - pub excludedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSelectorsReturn) -> Self { - (value.excludedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - excludedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSelectors()"; - const SELECTOR: [u8; 4] = [176u8, 70u8, 79u8, 220u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSelectorsReturn = r.into(); - r.excludedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `excludeSenders()` and selector `0x1ed7831c`. -```solidity -function excludeSenders() external view returns (address[] memory excludedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`excludeSenders()`](excludeSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct excludeSendersReturn { - #[allow(missing_docs)] - pub excludedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for excludeSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: excludeSendersReturn) -> Self { - (value.excludedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for excludeSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { excludedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for excludeSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "excludeSenders()"; - const SELECTOR: [u8; 4] = [30u8, 215u8, 131u8, 28u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: excludeSendersReturn = r.into(); - r.excludedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `setUp()` and selector `0x0a9254e4`. -```solidity -function setUp() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct setUpCall; - ///Container type for the return parameters of the [`setUp()`](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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: setUpReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for setUpReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl setUpReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for setUpCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = setUpReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "setUp()"; - const SELECTOR: [u8; 4] = [10u8, 146u8, 84u8, 228u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - setUpReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `simulateForkAndTransfer(uint256,address,address,uint256)` and selector `0xf9ce0e5a`. -```solidity -function simulateForkAndTransfer(uint256 forkAtBlock, address sender, address receiver, uint256 amount) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferCall { - #[allow(missing_docs)] - pub forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub sender: alloy::sol_types::private::Address, - #[allow(missing_docs)] - pub receiver: 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 [`simulateForkAndTransfer(uint256,address,address,uint256)`](simulateForkAndTransferCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct simulateForkAndTransferReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - 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::Uint<256>, - ); - #[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::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferCall) -> Self { - (value.forkAtBlock, value.sender, value.receiver, value.amount) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - forkAtBlock: tuple.0, - sender: tuple.1, - receiver: tuple.2, - amount: tuple.3, - } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: simulateForkAndTransferReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for simulateForkAndTransferReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl simulateForkAndTransferReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken< - '_, - > { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for simulateForkAndTransferCall { - type Parameters<'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::Uint<256>, - ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = simulateForkAndTransferReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "simulateForkAndTransfer(uint256,address,address,uint256)"; - const SELECTOR: [u8; 4] = [249u8, 206u8, 14u8, 90u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.forkAtBlock), - ::tokenize( - &self.sender, - ), - ::tokenize( - &self.receiver, - ), - as alloy_sol_types::SolType>::tokenize(&self.amount), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - simulateForkAndTransferReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifactSelectors()` and selector `0x66d9a9a0`. -```solidity -function targetArtifactSelectors() external view returns (StdInvariant.FuzzArtifactSelector[] memory targetedArtifactSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifactSelectors()`](targetArtifactSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactSelectorsReturn { - #[allow(missing_docs)] - pub targetedArtifactSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactSelectorsReturn) -> Self { - (value.targetedArtifactSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifactSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifactSelectors()"; - const SELECTOR: [u8; 4] = [102u8, 217u8, 169u8, 160u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactSelectorsReturn = r.into(); - r.targetedArtifactSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetArtifacts()` and selector `0x85226c81`. -```solidity -function targetArtifacts() external view returns (string[] memory targetedArtifacts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetArtifacts()`](targetArtifactsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetArtifactsReturn { - #[allow(missing_docs)] - pub targetedArtifacts_: alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetArtifactsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetArtifactsReturn) -> Self { - (value.targetedArtifacts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetArtifactsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedArtifacts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetArtifactsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::String, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetArtifacts()"; - const SELECTOR: [u8; 4] = [133u8, 34u8, 108u8, 129u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetArtifactsReturn = r.into(); - r.targetedArtifacts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetContracts()` and selector `0x3f7286f4`. -```solidity -function targetContracts() external view returns (address[] memory targetedContracts_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetContracts()`](targetContractsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetContractsReturn { - #[allow(missing_docs)] - pub targetedContracts_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetContractsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetContractsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetContractsReturn) -> Self { - (value.targetedContracts_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetContractsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedContracts_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetContractsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetContracts()"; - const SELECTOR: [u8; 4] = [63u8, 114u8, 134u8, 244u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetContractsReturn = r.into(); - r.targetedContracts_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetInterfaces()` and selector `0x2ade3880`. -```solidity -function targetInterfaces() external view returns (StdInvariant.FuzzInterface[] memory targetedInterfaces_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetInterfaces()`](targetInterfacesCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetInterfacesReturn { - #[allow(missing_docs)] - pub targetedInterfaces_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetInterfacesReturn) -> Self { - (value.targetedInterfaces_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetInterfacesReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedInterfaces_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetInterfacesCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetInterfaces()"; - const SELECTOR: [u8; 4] = [42u8, 222u8, 56u8, 128u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetInterfacesReturn = r.into(); - r.targetedInterfaces_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSelectors()` and selector `0x916a17c6`. -```solidity -function targetSelectors() external view returns (StdInvariant.FuzzSelector[] memory targetedSelectors_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSelectors()`](targetSelectorsCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSelectorsReturn { - #[allow(missing_docs)] - pub targetedSelectors_: alloy::sol_types::private::Vec< - ::RustType, - >, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSelectorsCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec< - ::RustType, - >, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: targetSelectorsReturn) -> Self { - (value.targetedSelectors_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for targetSelectorsReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - targetedSelectors_: tuple.0, - } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSelectorsCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - ::RustType, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSelectors()"; - const SELECTOR: [u8; 4] = [145u8, 106u8, 23u8, 198u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSelectorsReturn = r.into(); - r.targetedSelectors_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `targetSenders()` and selector `0x3e5e3c23`. -```solidity -function targetSenders() external view returns (address[] memory targetedSenders_); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`targetSenders()`](targetSendersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct targetSendersReturn { - #[allow(missing_docs)] - pub targetedSenders_: 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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: targetSendersReturn) -> Self { - (value.targetedSenders_,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for targetSendersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { targetedSenders_: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for targetSendersCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "targetSenders()"; - const SELECTOR: [u8; 4] = [62u8, 94u8, 60u8, 35u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: targetSendersReturn = r.into(); - r.targetedSenders_ - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testSolvBTCStrategy()` and selector `0x7eec06b2`. -```solidity -function testSolvBTCStrategy() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testSolvBTCStrategyCall; - ///Container type for the return parameters of the [`testSolvBTCStrategy()`](testSolvBTCStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testSolvBTCStrategyReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testSolvBTCStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testSolvBTCStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testSolvBTCStrategyReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testSolvBTCStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testSolvBTCStrategyReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testSolvBTCStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testSolvBTCStrategyReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testSolvBTCStrategy()"; - const SELECTOR: [u8; 4] = [126u8, 236u8, 6u8, 178u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testSolvBTCStrategyReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `testSolvLSTStrategy()` and selector `0xf7f08cfb`. -```solidity -function testSolvLSTStrategy() external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testSolvLSTStrategyCall; - ///Container type for the return parameters of the [`testSolvLSTStrategy()`](testSolvLSTStrategyCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct testSolvLSTStrategyReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testSolvLSTStrategyCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testSolvLSTStrategyCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: testSolvLSTStrategyReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for testSolvLSTStrategyReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl testSolvLSTStrategyReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for testSolvLSTStrategyCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = testSolvLSTStrategyReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "testSolvLSTStrategy()"; - const SELECTOR: [u8; 4] = [247u8, 240u8, 140u8, 251u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - testSolvLSTStrategyReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `token()` and selector `0xfc0c546a`. -```solidity -function token() external view returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`token()`](tokenCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct tokenReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: tokenReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for tokenReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for tokenCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "token()"; - const SELECTOR: [u8; 4] = [252u8, 12u8, 84u8, 106u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: tokenReturn = r.into(); - r._0 - }) - } - } - }; - ///Container for all the [`SolvStrategyForked`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum SolvStrategyForkedCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - excludeArtifacts(excludeArtifactsCall), - #[allow(missing_docs)] - excludeContracts(excludeContractsCall), - #[allow(missing_docs)] - excludeSelectors(excludeSelectorsCall), - #[allow(missing_docs)] - excludeSenders(excludeSendersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - setUp(setUpCall), - #[allow(missing_docs)] - simulateForkAndTransfer(simulateForkAndTransferCall), - #[allow(missing_docs)] - targetArtifactSelectors(targetArtifactSelectorsCall), - #[allow(missing_docs)] - targetArtifacts(targetArtifactsCall), - #[allow(missing_docs)] - targetContracts(targetContractsCall), - #[allow(missing_docs)] - targetInterfaces(targetInterfacesCall), - #[allow(missing_docs)] - targetSelectors(targetSelectorsCall), - #[allow(missing_docs)] - targetSenders(targetSendersCall), - #[allow(missing_docs)] - testSolvBTCStrategy(testSolvBTCStrategyCall), - #[allow(missing_docs)] - testSolvLSTStrategy(testSolvLSTStrategyCall), - #[allow(missing_docs)] - token(tokenCall), - } - #[automatically_derived] - impl SolvStrategyForkedCalls { - /// 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]] = &[ - [10u8, 146u8, 84u8, 228u8], - [30u8, 215u8, 131u8, 28u8], - [42u8, 222u8, 56u8, 128u8], - [62u8, 94u8, 60u8, 35u8], - [63u8, 114u8, 134u8, 244u8], - [102u8, 217u8, 169u8, 160u8], - [126u8, 236u8, 6u8, 178u8], - [133u8, 34u8, 108u8, 129u8], - [145u8, 106u8, 23u8, 198u8], - [176u8, 70u8, 79u8, 220u8], - [181u8, 80u8, 138u8, 169u8], - [186u8, 65u8, 79u8, 166u8], - [226u8, 12u8, 159u8, 113u8], - [247u8, 240u8, 140u8, 251u8], - [249u8, 206u8, 14u8, 90u8], - [250u8, 118u8, 38u8, 212u8], - [252u8, 12u8, 84u8, 106u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for SolvStrategyForkedCalls { - const NAME: &'static str = "SolvStrategyForkedCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 17usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::excludeArtifacts(_) => { - ::SELECTOR - } - Self::excludeContracts(_) => { - ::SELECTOR - } - Self::excludeSelectors(_) => { - ::SELECTOR - } - Self::excludeSenders(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::setUp(_) => ::SELECTOR, - Self::simulateForkAndTransfer(_) => { - ::SELECTOR - } - Self::targetArtifactSelectors(_) => { - ::SELECTOR - } - Self::targetArtifacts(_) => { - ::SELECTOR - } - Self::targetContracts(_) => { - ::SELECTOR - } - Self::targetInterfaces(_) => { - ::SELECTOR - } - Self::targetSelectors(_) => { - ::SELECTOR - } - Self::targetSenders(_) => { - ::SELECTOR - } - Self::testSolvBTCStrategy(_) => { - ::SELECTOR - } - Self::testSolvLSTStrategy(_) => { - ::SELECTOR - } - Self::token(_) => ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(SolvStrategyForkedCalls::setUp) - } - setUp - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SolvStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SolvStrategyForkedCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SolvStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SolvStrategyForkedCalls::targetContracts) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SolvStrategyForkedCalls::targetArtifactSelectors) - } - targetArtifactSelectors - }, - { - fn testSolvBTCStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SolvStrategyForkedCalls::testSolvBTCStrategy) - } - testSolvBTCStrategy - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SolvStrategyForkedCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SolvStrategyForkedCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SolvStrategyForkedCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SolvStrategyForkedCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(SolvStrategyForkedCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SolvStrategyForkedCalls::excludeContracts) - } - excludeContracts - }, - { - fn testSolvLSTStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SolvStrategyForkedCalls::testSolvLSTStrategy) - } - testSolvLSTStrategy - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(SolvStrategyForkedCalls::simulateForkAndTransfer) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(SolvStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(SolvStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn setUp( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvStrategyForkedCalls::setUp) - } - setUp - }, - { - fn excludeSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvStrategyForkedCalls::excludeSenders) - } - excludeSenders - }, - { - fn targetInterfaces( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvStrategyForkedCalls::targetInterfaces) - } - targetInterfaces - }, - { - fn targetSenders( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvStrategyForkedCalls::targetSenders) - } - targetSenders - }, - { - fn targetContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvStrategyForkedCalls::targetContracts) - } - targetContracts - }, - { - fn targetArtifactSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvStrategyForkedCalls::targetArtifactSelectors) - } - targetArtifactSelectors - }, - { - fn testSolvBTCStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvStrategyForkedCalls::testSolvBTCStrategy) - } - testSolvBTCStrategy - }, - { - fn targetArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvStrategyForkedCalls::targetArtifacts) - } - targetArtifacts - }, - { - fn targetSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvStrategyForkedCalls::targetSelectors) - } - targetSelectors - }, - { - fn excludeSelectors( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvStrategyForkedCalls::excludeSelectors) - } - excludeSelectors - }, - { - fn excludeArtifacts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvStrategyForkedCalls::excludeArtifacts) - } - excludeArtifacts - }, - { - fn failed( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvStrategyForkedCalls::failed) - } - failed - }, - { - fn excludeContracts( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvStrategyForkedCalls::excludeContracts) - } - excludeContracts - }, - { - fn testSolvLSTStrategy( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvStrategyForkedCalls::testSolvLSTStrategy) - } - testSolvLSTStrategy - }, - { - fn simulateForkAndTransfer( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvStrategyForkedCalls::simulateForkAndTransfer) - } - simulateForkAndTransfer - }, - { - fn IS_TEST( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvStrategyForkedCalls::IS_TEST) - } - IS_TEST - }, - { - fn token( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(SolvStrategyForkedCalls::token) - } - token - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::excludeArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::excludeSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::setUp(inner) => { - ::abi_encoded_size(inner) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetContracts(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSelectors(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::targetSenders(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testSolvBTCStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::testSolvLSTStrategy(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::token(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::excludeArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::excludeSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::setUp(inner) => { - ::abi_encode_raw(inner, out) - } - Self::simulateForkAndTransfer(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifactSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetArtifacts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetContracts(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetInterfaces(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSelectors(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::targetSenders(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testSolvBTCStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::testSolvLSTStrategy(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::token(inner) => { - ::abi_encode_raw(inner, out) - } - } - } - } - ///Container for all the [`SolvStrategyForked`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum SolvStrategyForkedEvents { - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_array_0(log_array_0), - #[allow(missing_docs)] - log_array_1(log_array_1), - #[allow(missing_docs)] - log_array_2(log_array_2), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_array_0(log_named_array_0), - #[allow(missing_docs)] - log_named_array_1(log_named_array_1), - #[allow(missing_docs)] - log_named_array_2(log_named_array_2), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl SolvStrategyForkedEvents { - /// 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]] = &[ - [ - 0u8, 170u8, 163u8, 156u8, 159u8, 251u8, 95u8, 86u8, 122u8, 69u8, 52u8, - 56u8, 12u8, 115u8, 112u8, 117u8, 112u8, 46u8, 31u8, 127u8, 20u8, 16u8, - 127u8, 201u8, 83u8, 40u8, 227u8, 181u8, 108u8, 3u8, 37u8, 251u8, - ], - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 59u8, 207u8, 178u8, 174u8, 46u8, 141u8, 19u8, 45u8, 209u8, 252u8, 231u8, - 207u8, 39u8, 138u8, 154u8, 25u8, 117u8, 106u8, 159u8, 206u8, 171u8, - 228u8, 112u8, 223u8, 59u8, 218u8, 187u8, 75u8, 197u8, 119u8, 209u8, 189u8, - ], - [ - 64u8, 225u8, 132u8, 15u8, 87u8, 105u8, 7u8, 61u8, 97u8, 189u8, 1u8, 55u8, - 45u8, 155u8, 117u8, 186u8, 169u8, 132u8, 45u8, 86u8, 41u8, 160u8, 201u8, - 159u8, 241u8, 3u8, 190u8, 17u8, 120u8, 168u8, 233u8, 226u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 137u8, 10u8, 130u8, 103u8, 155u8, 71u8, 15u8, 43u8, 216u8, 40u8, 22u8, - 237u8, 155u8, 22u8, 31u8, 151u8, 216u8, 185u8, 103u8, 243u8, 127u8, - 163u8, 100u8, 124u8, 33u8, 213u8, 191u8, 57u8, 116u8, 158u8, 45u8, 213u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 167u8, 62u8, 218u8, 9u8, 102u8, 47u8, 70u8, 221u8, 231u8, 41u8, 190u8, - 70u8, 17u8, 56u8, 95u8, 243u8, 79u8, 230u8, 196u8, 79u8, 187u8, 198u8, - 247u8, 225u8, 123u8, 4u8, 43u8, 89u8, 163u8, 68u8, 91u8, 87u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - [ - 251u8, 16u8, 40u8, 101u8, 213u8, 10u8, 221u8, 221u8, 246u8, 157u8, 169u8, - 181u8, 170u8, 27u8, 206u8, 214u8, 108u8, 128u8, 207u8, 134u8, 154u8, - 92u8, 141u8, 4u8, 113u8, 164u8, 103u8, 225u8, 140u8, 233u8, 202u8, 177u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for SolvStrategyForkedEvents { - const NAME: &'static str = "SolvStrategyForkedEvents"; - const COUNT: usize = 22usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_0) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_1) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_0) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_1) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_array_2) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 SolvStrategyForkedEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_0(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_1(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_array_2(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`SolvStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`SolvStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> SolvStrategyForkedInstance { - SolvStrategyForkedInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - SolvStrategyForkedInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - SolvStrategyForkedInstance::::deploy_builder(provider) - } - /**A [`SolvStrategyForked`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`SolvStrategyForked`](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 SolvStrategyForkedInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for SolvStrategyForkedInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("SolvStrategyForkedInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SolvStrategyForkedInstance { - /**Creates a new wrapper around an on-chain [`SolvStrategyForked`](self) contract instance. - -See the [wrapper's documentation](`SolvStrategyForkedInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 SolvStrategyForkedInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> SolvStrategyForkedInstance { - SolvStrategyForkedInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SolvStrategyForkedInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`excludeArtifacts`] function. - pub fn excludeArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeArtifactsCall, N> { - self.call_builder(&excludeArtifactsCall) - } - ///Creates a new call builder for the [`excludeContracts`] function. - pub fn excludeContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeContractsCall, N> { - self.call_builder(&excludeContractsCall) - } - ///Creates a new call builder for the [`excludeSelectors`] function. - pub fn excludeSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSelectorsCall, N> { - self.call_builder(&excludeSelectorsCall) - } - ///Creates a new call builder for the [`excludeSenders`] function. - pub fn excludeSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, excludeSendersCall, N> { - self.call_builder(&excludeSendersCall) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`setUp`] function. - pub fn setUp(&self) -> alloy_contract::SolCallBuilder<&P, setUpCall, N> { - self.call_builder(&setUpCall) - } - ///Creates a new call builder for the [`simulateForkAndTransfer`] function. - pub fn simulateForkAndTransfer( - &self, - forkAtBlock: alloy::sol_types::private::primitives::aliases::U256, - sender: alloy::sol_types::private::Address, - receiver: alloy::sol_types::private::Address, - amount: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, simulateForkAndTransferCall, N> { - self.call_builder( - &simulateForkAndTransferCall { - forkAtBlock, - sender, - receiver, - amount, - }, - ) - } - ///Creates a new call builder for the [`targetArtifactSelectors`] function. - pub fn targetArtifactSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactSelectorsCall, N> { - self.call_builder(&targetArtifactSelectorsCall) - } - ///Creates a new call builder for the [`targetArtifacts`] function. - pub fn targetArtifacts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetArtifactsCall, N> { - self.call_builder(&targetArtifactsCall) - } - ///Creates a new call builder for the [`targetContracts`] function. - pub fn targetContracts( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetContractsCall, N> { - self.call_builder(&targetContractsCall) - } - ///Creates a new call builder for the [`targetInterfaces`] function. - pub fn targetInterfaces( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetInterfacesCall, N> { - self.call_builder(&targetInterfacesCall) - } - ///Creates a new call builder for the [`targetSelectors`] function. - pub fn targetSelectors( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSelectorsCall, N> { - self.call_builder(&targetSelectorsCall) - } - ///Creates a new call builder for the [`targetSenders`] function. - pub fn targetSenders( - &self, - ) -> alloy_contract::SolCallBuilder<&P, targetSendersCall, N> { - self.call_builder(&targetSendersCall) - } - ///Creates a new call builder for the [`testSolvBTCStrategy`] function. - pub fn testSolvBTCStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testSolvBTCStrategyCall, N> { - self.call_builder(&testSolvBTCStrategyCall) - } - ///Creates a new call builder for the [`testSolvLSTStrategy`] function. - pub fn testSolvLSTStrategy( - &self, - ) -> alloy_contract::SolCallBuilder<&P, testSolvLSTStrategyCall, N> { - self.call_builder(&testSolvLSTStrategyCall) - } - ///Creates a new call builder for the [`token`] function. - pub fn token(&self) -> alloy_contract::SolCallBuilder<&P, tokenCall, N> { - self.call_builder(&tokenCall) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > SolvStrategyForkedInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_0`] event. - pub fn log_array_0_filter(&self) -> alloy_contract::Event<&P, log_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_1`] event. - pub fn log_array_1_filter(&self) -> alloy_contract::Event<&P, log_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_array_2`] event. - pub fn log_array_2_filter(&self) -> alloy_contract::Event<&P, log_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_0`] event. - pub fn log_named_array_0_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_0, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_1`] event. - pub fn log_named_array_1_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_1, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_array_2`] event. - pub fn log_named_array_2_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_array_2, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/std_constants.rs b/crates/bindings/src/std_constants.rs deleted file mode 100644 index 795031119..000000000 --- a/crates/bindings/src/std_constants.rs +++ /dev/null @@ -1,218 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface StdConstants {} -``` - -...which was generated by the following JSON ABI: -```json -[] -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod StdConstants { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212207bd4df70c18f4df42840c49b2e801fd97f3ffafa3607a730693555f9ea229b4264736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"`U`2`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`&WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 {\xD4\xDFp\xC1\x8FM\xF4(@\xC4\x9B.\x80\x1F\xD9\x7F?\xFA\xFA6\x07\xA70i5U\xF9\xEA\"\x9BBdsolcC\0\x08\x1C\x003", - ); - /// The runtime bytecode of the contract, as deployed on the network. - /// - /// ```text - ///0x730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212207bd4df70c18f4df42840c49b2e801fd97f3ffafa3607a730693555f9ea229b4264736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 {\xD4\xDFp\xC1\x8FM\xF4(@\xC4\x9B.\x80\x1F\xD9\x7F?\xFA\xFA6\x07\xA70i5U\xF9\xEA\"\x9BBdsolcC\0\x08\x1C\x003", - ); - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`StdConstants`](self) contract instance. - -See the [wrapper's documentation](`StdConstantsInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> StdConstantsInstance { - StdConstantsInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - StdConstantsInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - StdConstantsInstance::::deploy_builder(provider) - } - /**A [`StdConstants`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`StdConstants`](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 StdConstantsInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StdConstantsInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StdConstantsInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdConstantsInstance { - /**Creates a new wrapper around an on-chain [`StdConstants`](self) contract instance. - -See the [wrapper's documentation](`StdConstantsInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 StdConstantsInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StdConstantsInstance { - StdConstantsInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdConstantsInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StdConstantsInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/strings.rs b/crates/bindings/src/strings.rs deleted file mode 100644 index 54f105906..000000000 --- a/crates/bindings/src/strings.rs +++ /dev/null @@ -1,215 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface Strings {} -``` - -...which was generated by the following JSON ABI: -```json -[] -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod Strings { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212201a58bdbfa53ac597b4722b5f67b03f2713f6c1425269a67f09d3aad6574b4bea64736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"`U`2`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`&WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \x1AX\xBD\xBF\xA5:\xC5\x97\xB4r+_g\xB0?'\x13\xF6\xC1BRi\xA6\x7F\t\xD3\xAA\xD6WKK\xEAdsolcC\0\x08\x1C\x003", - ); - /// The runtime bytecode of the contract, as deployed on the network. - /// - /// ```text - ///0x730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212201a58bdbfa53ac597b4722b5f67b03f2713f6c1425269a67f09d3aad6574b4bea64736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \x1AX\xBD\xBF\xA5:\xC5\x97\xB4r+_g\xB0?'\x13\xF6\xC1BRi\xA6\x7F\t\xD3\xAA\xD6WKK\xEAdsolcC\0\x08\x1C\x003", - ); - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`Strings`](self) contract instance. - -See the [wrapper's documentation](`StringsInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >(address: alloy_sol_types::private::Address, provider: P) -> StringsInstance { - StringsInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - StringsInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - StringsInstance::::deploy_builder(provider) - } - /**A [`Strings`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`Strings`](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 StringsInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for StringsInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("StringsInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StringsInstance { - /**Creates a new wrapper around an on-chain [`Strings`](self) contract instance. - -See the [wrapper's documentation](`StringsInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 StringsInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> StringsInstance { - StringsInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StringsInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > StringsInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/utilities.rs b/crates/bindings/src/utilities.rs deleted file mode 100644 index cd31959cf..000000000 --- a/crates/bindings/src/utilities.rs +++ /dev/null @@ -1,3808 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface Utilities { - event log(string); - event log_address(address); - event log_bytes(bytes); - event log_bytes32(bytes32); - event log_int(int256); - event log_named_address(string key, address val); - event log_named_bytes(string key, bytes val); - event log_named_bytes32(string key, bytes32 val); - event log_named_decimal_int(string key, int256 val, uint256 decimals); - event log_named_decimal_uint(string key, uint256 val, uint256 decimals); - event log_named_int(string key, int256 val); - event log_named_string(string key, string val); - event log_named_uint(string key, uint256 val); - event log_string(string); - event log_uint(uint256); - event logs(bytes); - - function IS_TEST() external view returns (bool); - function createUsers(uint256 userNum) external returns (address payable[] memory); - function failed() external returns (bool); - function getNextUserAddress() external returns (address payable); - function mineBlocks(uint256 numBlocks) external; -} -``` - -...which was generated by the following JSON ABI: -```json -[ - { - "type": "function", - "name": "IS_TEST", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "view" - }, - { - "type": "function", - "name": "createUsers", - "inputs": [ - { - "name": "userNum", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [ - { - "name": "", - "type": "address[]", - "internalType": "address payable[]" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "failed", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "bool", - "internalType": "bool" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "getNextUserAddress", - "inputs": [], - "outputs": [ - { - "name": "", - "type": "address", - "internalType": "address payable" - } - ], - "stateMutability": "nonpayable" - }, - { - "type": "function", - "name": "mineBlocks", - "inputs": [ - { - "name": "numBlocks", - "type": "uint256", - "internalType": "uint256" - } - ], - "outputs": [], - "stateMutability": "nonpayable" - }, - { - "type": "event", - "name": "log", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_address", - "inputs": [ - { - "name": "", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes", - "inputs": [ - { - "name": "", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_bytes32", - "inputs": [ - { - "name": "", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_int", - "inputs": [ - { - "name": "", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_address", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "address", - "indexed": false, - "internalType": "address" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes", - "indexed": false, - "internalType": "bytes" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_bytes32", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "bytes32", - "indexed": false, - "internalType": "bytes32" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_decimal_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - }, - { - "name": "decimals", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_int", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "int256", - "indexed": false, - "internalType": "int256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_string", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_named_uint", - "inputs": [ - { - "name": "key", - "type": "string", - "indexed": false, - "internalType": "string" - }, - { - "name": "val", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_string", - "inputs": [ - { - "name": "", - "type": "string", - "indexed": false, - "internalType": "string" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "log_uint", - "inputs": [ - { - "name": "", - "type": "uint256", - "indexed": false, - "internalType": "uint256" - } - ], - "anonymous": false - }, - { - "type": "event", - "name": "logs", - "inputs": [ - { - "name": "", - "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 Utilities { - use super::*; - use alloy::sol_types as 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"_\x80T`\xFF\x19\x16`\x01\x90\x81\x17\x90\x91Usq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-`\x80Rkuser address`\xA0\x1B`\xC0R`\x0C`\xA0R`\xCC`@R\x7F\xFA\xDDiS\xA0Cn\x85R\x8D\xEDx\x9A\xF2\xE2\xB7\xE5|\x1C\xD7\xC6\x8C\\7\x96\xD8\xEAg\xE0\x01\x8D\xB7\x90U4\x80\x15`pW__\xFD[P`\x80Qa\x06\xC5a\0\x90_9_\x81\x81a\x02,\x01Ra\x04b\x01Ra\x06\xC5_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0dW_5`\xE0\x1C\x80c\xBAAO\xA6\x11a\0MW\x80c\xBAAO\xA6\x14a\0\xDBW\x80c\xF8-\xE7\xB0\x14a\0\xF3W\x80c\xFAv&\xD4\x14a\x01\x08W__\xFD[\x80cy.\x11\xF5\x14a\0hW\x80c\xB9\nh\xFA\x14a\0\x91W[__\xFD[a\0{a\0v6`\x04a\x04\xD2V[a\x01\x14V[`@Qa\0\x88\x91\x90a\x04\xE9V[`@Q\x80\x91\x03\x90\xF3[`\x01\x80T`@\x80Q` \x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x82\x01\x81R\x82\x84\x01\x93\x84\x90R\x80Q\x91\x01 \x90\x93Us\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x90R``\x01a\0\x88V[a\0\xE3a\x02\xCDV[`@Q\x90\x15\x15\x81R` \x01a\0\x88V[a\x01\x06a\x01\x016`\x04a\x04\xD2V[a\x04%V[\0[_Ta\0\xE3\x90`\xFF\x16\x81V[``_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x010Wa\x010a\x05AV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x01YW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x83\x81\x10\x15a\x02\xC6W_0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xB9\nh\xFA`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\xB1W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xD5\x91\x90a\x05nV[`@Q\x7F\xC8\x8A^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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x83\x16`\x04\x83\x01Rh\x05k\xC7^-c\x10\0\0`$\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\xC8\x8A^m\x90`D\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02oW__\xFD[PZ\xF1\x15\x80\x15a\x02\x81W=__>=_\xFD[PPPP\x80\x83\x83\x81Q\x81\x10a\x02\x98Wa\x02\x98a\x05\xA8V[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\x90\x91\x01RP`\x01\x01a\x01^V[P\x92\x91PPV[_\x80Ta\x01\0\x90\x04`\xFF\x16\x15a\x02\xEBWP_Ta\x01\0\x90\x04`\xFF\x16\x90V[_sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-;\x15a\x04 W`@\x80Qsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-` \x82\x01\x81\x90R\x7Ffailed\0\0\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\x82Q\x80\x83\x03\x84\x01\x81R``\x83\x01\x90\x93R_\x92\x90\x91a\x03\x8E\x91\x7Ff\x7F\x9Dp\xCAA\x1Dp\xEA\xD5\r\x8D\\\"\x07\r\xAF\xC3j\xD7_=\xCF^r7\xB2*\xDE\x9A\xEC\xC4\x91`\x80\x01a\x05\xECV[`@\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\x03\xC6\x91a\x06'V[_`@Q\x80\x83\x03\x81_\x86Z\xF1\x91PP=\x80_\x81\x14a\x03\xFFW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x04\x04V[``\x91P[P\x91PP\x80\x80` \x01\x90Q\x81\x01\x90a\x04\x1C\x91\x90a\x062V[\x91PP[\x91\x90PV[_a\x040\x82Ca\x06QV[`@Q\x7F\x1F{O0\0\0\0\0\0\0\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\x90\x91P\x7F\0\0\0\0\0\0\0\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\x1F{O0\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xB8W__\xFD[PZ\xF1\x15\x80\x15a\x04\xCAW=__>=_\xFD[PPPPPPV[_` \x82\x84\x03\x12\x15a\x04\xE2W__\xFD[P5\x91\x90PV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x056W\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\x05\x02V[P\x90\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x05~W__\xFD[\x81Qs\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\xA1W__\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[\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\x83\x16\x81R_a\x06\x1F`\x04\x83\x01\x84a\x05\xD5V[\x94\x93PPPPV[_a\x05\xA1\x82\x84a\x05\xD5V[_` \x82\x84\x03\x12\x15a\x06BW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x05\xA1W__\xFD[\x80\x82\x01\x80\x82\x11\x15a\x06\x89W\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\xA2dipfsX\"\x12 =\x07\xDC\x81\xE0Oz\xBB\x85\x1BO`p\xD3\xDA\xBFx\xFB\x08\xE9 1\x1D\xBA\xA4\xE1i\x83\x0B\x05\xDB\xE0dsolcC\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\0dW_5`\xE0\x1C\x80c\xBAAO\xA6\x11a\0MW\x80c\xBAAO\xA6\x14a\0\xDBW\x80c\xF8-\xE7\xB0\x14a\0\xF3W\x80c\xFAv&\xD4\x14a\x01\x08W__\xFD[\x80cy.\x11\xF5\x14a\0hW\x80c\xB9\nh\xFA\x14a\0\x91W[__\xFD[a\0{a\0v6`\x04a\x04\xD2V[a\x01\x14V[`@Qa\0\x88\x91\x90a\x04\xE9V[`@Q\x80\x91\x03\x90\xF3[`\x01\x80T`@\x80Q` \x80\x82\x01\x84\x90R\x82Q\x80\x83\x03\x82\x01\x81R\x82\x84\x01\x93\x84\x90R\x80Q\x91\x01 \x90\x93Us\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x90R``\x01a\0\x88V[a\0\xE3a\x02\xCDV[`@Q\x90\x15\x15\x81R` \x01a\0\x88V[a\x01\x06a\x01\x016`\x04a\x04\xD2V[a\x04%V[\0[_Ta\0\xE3\x90`\xFF\x16\x81V[``_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x010Wa\x010a\x05AV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x01YW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x83\x81\x10\x15a\x02\xC6W_0s\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16c\xB9\nh\xFA`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81_\x87Z\xF1\x15\x80\x15a\x01\xB1W=__>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xD5\x91\x90a\x05nV[`@Q\x7F\xC8\x8A^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\x81Rs\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x83\x16`\x04\x83\x01Rh\x05k\xC7^-c\x10\0\0`$\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\xC8\x8A^m\x90`D\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x02oW__\xFD[PZ\xF1\x15\x80\x15a\x02\x81W=__>=_\xFD[PPPP\x80\x83\x83\x81Q\x81\x10a\x02\x98Wa\x02\x98a\x05\xA8V[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\x90\x91\x01RP`\x01\x01a\x01^V[P\x92\x91PPV[_\x80Ta\x01\0\x90\x04`\xFF\x16\x15a\x02\xEBWP_Ta\x01\0\x90\x04`\xFF\x16\x90V[_sq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-;\x15a\x04 W`@\x80Qsq\tp\x9E\xCF\xA9\x1A\x80bo\xF3\x98\x9Dh\xF6\x7F[\x1D\xD1-` \x82\x01\x81\x90R\x7Ffailed\0\0\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\x82Q\x80\x83\x03\x84\x01\x81R``\x83\x01\x90\x93R_\x92\x90\x91a\x03\x8E\x91\x7Ff\x7F\x9Dp\xCAA\x1Dp\xEA\xD5\r\x8D\\\"\x07\r\xAF\xC3j\xD7_=\xCF^r7\xB2*\xDE\x9A\xEC\xC4\x91`\x80\x01a\x05\xECV[`@\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\x03\xC6\x91a\x06'V[_`@Q\x80\x83\x03\x81_\x86Z\xF1\x91PP=\x80_\x81\x14a\x03\xFFW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x04\x04V[``\x91P[P\x91PP\x80\x80` \x01\x90Q\x81\x01\x90a\x04\x1C\x91\x90a\x062V[\x91PP[\x91\x90PV[_a\x040\x82Ca\x06QV[`@Q\x7F\x1F{O0\0\0\0\0\0\0\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\x90\x91P\x7F\0\0\0\0\0\0\0\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\x1F{O0\x90`$\x01_`@Q\x80\x83\x03\x81_\x87\x80;\x15\x80\x15a\x04\xB8W__\xFD[PZ\xF1\x15\x80\x15a\x04\xCAW=__>=_\xFD[PPPPPPV[_` \x82\x84\x03\x12\x15a\x04\xE2W__\xFD[P5\x91\x90PV[` \x80\x82R\x82Q\x82\x82\x01\x81\x90R_\x91\x84\x01\x90`@\x84\x01\x90\x83[\x81\x81\x10\x15a\x056W\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\x05\x02V[P\x90\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`A`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x05~W__\xFD[\x81Qs\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\xA1W__\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[_\x81Q\x80` \x84\x01\x85^_\x93\x01\x92\x83RP\x90\x91\x90PV[\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\x83\x16\x81R_a\x06\x1F`\x04\x83\x01\x84a\x05\xD5V[\x94\x93PPPPV[_a\x05\xA1\x82\x84a\x05\xD5V[_` \x82\x84\x03\x12\x15a\x06BW__\xFD[\x81Q\x80\x15\x15\x81\x14a\x05\xA1W__\xFD[\x80\x82\x01\x80\x82\x11\x15a\x06\x89W\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\xA2dipfsX\"\x12 =\x07\xDC\x81\xE0Oz\xBB\x85\x1BO`p\xD3\xDA\xBFx\xFB\x08\xE9 1\x1D\xBA\xA4\xE1i\x83\x0B\x05\xDB\xE0dsolcC\0\x08\x1C\x003", - ); - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log(string)` and selector `0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50`. -```solidity -event log(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_address(address)` and selector `0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3`. -```solidity -event log_address(address); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_address { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_address { - type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_address(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes(bytes)` and selector `0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20`. -```solidity -event log_bytes(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_bytes32(bytes32)` and selector `0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3`. -```solidity -event log_bytes32(bytes32); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_bytes32 { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_bytes32 { - type DataTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_bytes32(bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_int(int256)` and selector `0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8`. -```solidity -event log_int(int256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_int { - #[allow(missing_docs)] - pub _0: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_int { - type DataTuple<'a> = (alloy::sol_types::sol_data::Int<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_int(int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_address(string,address)` and selector `0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f`. -```solidity -event log_named_address(string key, address val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_address { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Address, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_address { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Address, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_address(string,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_address { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_address> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_address) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes(string,bytes)` and selector `0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18`. -```solidity -event log_named_bytes(string key, bytes val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::Bytes, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Bytes, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes(string,bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_bytes32(string,bytes32)` and selector `0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99`. -```solidity -event log_named_bytes32(string key, bytes32 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_bytes32 { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_bytes32 { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::FixedBytes<32>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_bytes32(string,bytes32)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_bytes32 { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_bytes32> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_bytes32) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_int(string,int256,uint256)` and selector `0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95`. -```solidity -event log_named_decimal_int(string key, int256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::I256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_int(string,int256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_decimal_uint(string,uint256,uint256)` and selector `0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b`. -```solidity -event log_named_decimal_uint(string key, uint256 val, uint256 decimals); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_decimal_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - #[allow(missing_docs)] - pub decimals: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_decimal_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_decimal_uint(string,uint256,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { - key: data.0, - val: data.1, - decimals: data.2, - } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - as alloy_sol_types::SolType>::tokenize(&self.decimals), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_decimal_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_decimal_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_decimal_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_int(string,int256)` and selector `0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168`. -```solidity -event log_named_int(string key, int256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_int { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: 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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_int { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Int<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_int(string,int256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_int { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_int> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_int) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_string(string,string)` and selector `0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583`. -```solidity -event log_named_string(string key, string val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_string { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::String, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_string { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::String, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_string(string,string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - ::tokenize( - &self.val, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_named_uint(string,uint256)` and selector `0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8`. -```solidity -event log_named_uint(string key, uint256 val); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_named_uint { - #[allow(missing_docs)] - pub key: alloy::sol_types::private::String, - #[allow(missing_docs)] - pub val: alloy::sol_types::private::primitives::aliases::U256, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_named_uint { - type DataTuple<'a> = ( - alloy::sol_types::sol_data::String, - alloy::sol_types::sol_data::Uint<256>, - ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_named_uint(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { key: data.0, val: data.1 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self.key, - ), - as alloy_sol_types::SolType>::tokenize(&self.val), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_named_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_named_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_named_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_string(string)` and selector `0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b`. -```solidity -event log_string(string); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_string { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_string { - type DataTuple<'a> = (alloy::sol_types::sol_data::String,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_string(string)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_string { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_string> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_string) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `log_uint(uint256)` and selector `0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755`. -```solidity -event log_uint(uint256); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct log_uint { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for log_uint { - type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "log_uint(uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self._0), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 log_uint { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&log_uint> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &log_uint) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Event with signature `logs(bytes)` and selector `0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4`. -```solidity -event logs(bytes); -```*/ - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - #[derive(Clone)] - pub struct logs { - #[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 as alloy_sol_types; - #[automatically_derived] - impl alloy_sol_types::SolEvent for logs { - type DataTuple<'a> = (alloy::sol_types::sol_data::Bytes,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); - const SIGNATURE: &'static str = "logs(bytes)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ]); - const ANONYMOUS: bool = false; - #[allow(unused_variables)] - #[inline] - fn new( - topics: ::RustType, - data: as alloy_sol_types::SolType>::RustType, - ) -> Self { - Self { _0: data.0 } - } - #[inline] - fn check_signature( - topics: &::RustType, - ) -> alloy_sol_types::Result<()> { - if topics.0 != Self::SIGNATURE_HASH { - return Err( - alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - ), - ); - } - Ok(()) - } - #[inline] - fn tokenize_body(&self) -> Self::DataToken<'_> { - ( - ::tokenize( - &self._0, - ), - ) - } - #[inline] - fn topics(&self) -> ::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() < ::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 logs { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - From::from(self) - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - From::from(&self) - } - } - #[automatically_derived] - impl From<&logs> for alloy_sol_types::private::LogData { - #[inline] - fn from(this: &logs) -> alloy_sol_types::private::LogData { - alloy_sol_types::SolEvent::encode_log_data(this) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `IS_TEST()` and selector `0xfa7626d4`. -```solidity -function IS_TEST() external view returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`IS_TEST()`](IS_TESTCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct IS_TESTReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: IS_TESTReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for IS_TESTReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for IS_TESTCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "IS_TEST()"; - const SELECTOR: [u8; 4] = [250u8, 118u8, 38u8, 212u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: IS_TESTReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `createUsers(uint256)` and selector `0x792e11f5`. -```solidity -function createUsers(uint256 userNum) external returns (address[] memory); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct createUsersCall { - #[allow(missing_docs)] - pub userNum: alloy::sol_types::private::primitives::aliases::U256, - } - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`createUsers(uint256)`](createUsersCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct createUsersReturn { - #[allow(missing_docs)] - pub _0: alloy::sol_types::private::Vec, - } - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: createUsersCall) -> Self { - (value.userNum,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for createUsersCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { userNum: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: createUsersReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for createUsersReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for createUsersCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Vec< - alloy::sol_types::private::Address, - >; - type ReturnTuple<'a> = ( - alloy::sol_types::sol_data::Array, - ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "createUsers(uint256)"; - const SELECTOR: [u8; 4] = [121u8, 46u8, 17u8, 245u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.userNum), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - as alloy_sol_types::SolType>::tokenize(ret), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: createUsersReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: createUsersReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `failed()` and selector `0xba414fa6`. -```solidity -function failed() external returns (bool); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`failed()`](failedCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct failedReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - 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, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: failedReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for failedReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for failedCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = bool; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "failed()"; - const SELECTOR: [u8; 4] = [186u8, 65u8, 79u8, 166u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: failedReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `getNextUserAddress()` and selector `0xb90a68fa`. -```solidity -function getNextUserAddress() external returns (address); -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getNextUserAddressCall; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - ///Container type for the return parameters of the [`getNextUserAddress()`](getNextUserAddressCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct getNextUserAddressReturn { - #[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 as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getNextUserAddressCall) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getNextUserAddressCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From - for UnderlyingRustTuple<'_> { - fn from(value: getNextUserAddressReturn) -> Self { - (value._0,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> - for getNextUserAddressReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { _0: tuple.0 } - } - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for getNextUserAddressCall { - type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = alloy::sol_types::private::Address; - type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "getNextUserAddress()"; - const SELECTOR: [u8; 4] = [185u8, 10u8, 104u8, 250u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - () - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - ( - ::tokenize( - ret, - ), - ) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(|r| { - let r: getNextUserAddressReturn = r.into(); - r._0 - }) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(|r| { - let r: getNextUserAddressReturn = r.into(); - r._0 - }) - } - } - }; - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Default, Debug, PartialEq, Eq, Hash)] - /**Function with signature `mineBlocks(uint256)` and selector `0xf82de7b0`. -```solidity -function mineBlocks(uint256 numBlocks) external; -```*/ - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct mineBlocksCall { - #[allow(missing_docs)] - pub numBlocks: alloy::sol_types::private::primitives::aliases::U256, - } - ///Container type for the return parameters of the [`mineBlocks(uint256)`](mineBlocksCall) function. - #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] - #[derive(Clone)] - pub struct mineBlocksReturn {} - #[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style - )] - const _: () = { - use alloy::sol_types as alloy_sol_types; - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::primitives::aliases::U256, - ); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: mineBlocksCall) -> Self { - (value.numBlocks,) - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for mineBlocksCall { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { numBlocks: tuple.0 } - } - } - } - { - #[doc(hidden)] - type UnderlyingSolTuple<'a> = (); - #[doc(hidden)] - type UnderlyingRustTuple<'a> = (); - #[cfg(test)] - #[allow(dead_code, unreachable_patterns)] - fn _type_assertion( - _t: alloy_sol_types::private::AssertTypeEq, - ) { - match _t { - alloy_sol_types::private::AssertTypeEq::< - ::RustType, - >(_) => {} - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { - fn from(value: mineBlocksReturn) -> Self { - () - } - } - #[automatically_derived] - #[doc(hidden)] - impl ::core::convert::From> for mineBlocksReturn { - fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self {} - } - } - } - impl mineBlocksReturn { - fn _tokenize( - &self, - ) -> ::ReturnToken<'_> { - () - } - } - #[automatically_derived] - impl alloy_sol_types::SolCall for mineBlocksCall { - type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = mineBlocksReturn; - type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = "mineBlocks(uint256)"; - const SELECTOR: [u8; 4] = [248u8, 45u8, 231u8, 176u8]; - #[inline] - fn new<'a>( - tuple: as alloy_sol_types::SolType>::RustType, - ) -> Self { - tuple.into() - } - #[inline] - fn tokenize(&self) -> Self::Token<'_> { - ( - as alloy_sol_types::SolType>::tokenize(&self.numBlocks), - ) - } - #[inline] - fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> { - mineBlocksReturn::_tokenize(ret) - } - #[inline] - fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence(data) - .map(Into::into) - } - #[inline] - fn abi_decode_returns_validate( - data: &[u8], - ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence_validate(data) - .map(Into::into) - } - } - }; - ///Container for all the [`Utilities`](self) function calls. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive()] - pub enum UtilitiesCalls { - #[allow(missing_docs)] - IS_TEST(IS_TESTCall), - #[allow(missing_docs)] - createUsers(createUsersCall), - #[allow(missing_docs)] - failed(failedCall), - #[allow(missing_docs)] - getNextUserAddress(getNextUserAddressCall), - #[allow(missing_docs)] - mineBlocks(mineBlocksCall), - } - #[automatically_derived] - impl UtilitiesCalls { - /// 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, 46u8, 17u8, 245u8], - [185u8, 10u8, 104u8, 250u8], - [186u8, 65u8, 79u8, 166u8], - [248u8, 45u8, 231u8, 176u8], - [250u8, 118u8, 38u8, 212u8], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolInterface for UtilitiesCalls { - const NAME: &'static str = "UtilitiesCalls"; - const MIN_DATA_LENGTH: usize = 0usize; - const COUNT: usize = 5usize; - #[inline] - fn selector(&self) -> [u8; 4] { - match self { - Self::IS_TEST(_) => ::SELECTOR, - Self::createUsers(_) => { - ::SELECTOR - } - Self::failed(_) => ::SELECTOR, - Self::getNextUserAddress(_) => { - ::SELECTOR - } - Self::mineBlocks(_) => { - ::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 { - static DECODE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn createUsers( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(UtilitiesCalls::createUsers) - } - createUsers - }, - { - fn getNextUserAddress( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(UtilitiesCalls::getNextUserAddress) - } - getNextUserAddress - }, - { - fn failed(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(UtilitiesCalls::failed) - } - failed - }, - { - fn mineBlocks( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, - ) - .map(UtilitiesCalls::mineBlocks) - } - mineBlocks - }, - { - fn IS_TEST(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw(data) - .map(UtilitiesCalls::IS_TEST) - } - IS_TEST - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::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 { - static DECODE_VALIDATE_SHIMS: &[fn( - &[u8], - ) -> alloy_sol_types::Result] = &[ - { - fn createUsers( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(UtilitiesCalls::createUsers) - } - createUsers - }, - { - fn getNextUserAddress( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(UtilitiesCalls::getNextUserAddress) - } - getNextUserAddress - }, - { - fn failed(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(UtilitiesCalls::failed) - } - failed - }, - { - fn mineBlocks( - data: &[u8], - ) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(UtilitiesCalls::mineBlocks) - } - mineBlocks - }, - { - fn IS_TEST(data: &[u8]) -> alloy_sol_types::Result { - ::abi_decode_raw_validate( - data, - ) - .map(UtilitiesCalls::IS_TEST) - } - IS_TEST - }, - ]; - let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err( - alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - ), - ); - }; - DECODE_VALIDATE_SHIMS[idx](data) - } - #[inline] - fn abi_encoded_size(&self) -> usize { - match self { - Self::IS_TEST(inner) => { - ::abi_encoded_size(inner) - } - Self::createUsers(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::failed(inner) => { - ::abi_encoded_size(inner) - } - Self::getNextUserAddress(inner) => { - ::abi_encoded_size( - inner, - ) - } - Self::mineBlocks(inner) => { - ::abi_encoded_size(inner) - } - } - } - #[inline] - fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { - match self { - Self::IS_TEST(inner) => { - ::abi_encode_raw(inner, out) - } - Self::createUsers(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::failed(inner) => { - ::abi_encode_raw(inner, out) - } - Self::getNextUserAddress(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - Self::mineBlocks(inner) => { - ::abi_encode_raw( - inner, - out, - ) - } - } - } - } - ///Container for all the [`Utilities`](self) events. - #[derive(serde::Serialize, serde::Deserialize)] - #[derive(Debug, PartialEq, Eq, Hash)] - pub enum UtilitiesEvents { - #[allow(missing_docs)] - log(log), - #[allow(missing_docs)] - log_address(log_address), - #[allow(missing_docs)] - log_bytes(log_bytes), - #[allow(missing_docs)] - log_bytes32(log_bytes32), - #[allow(missing_docs)] - log_int(log_int), - #[allow(missing_docs)] - log_named_address(log_named_address), - #[allow(missing_docs)] - log_named_bytes(log_named_bytes), - #[allow(missing_docs)] - log_named_bytes32(log_named_bytes32), - #[allow(missing_docs)] - log_named_decimal_int(log_named_decimal_int), - #[allow(missing_docs)] - log_named_decimal_uint(log_named_decimal_uint), - #[allow(missing_docs)] - log_named_int(log_named_int), - #[allow(missing_docs)] - log_named_string(log_named_string), - #[allow(missing_docs)] - log_named_uint(log_named_uint), - #[allow(missing_docs)] - log_string(log_string), - #[allow(missing_docs)] - log_uint(log_uint), - #[allow(missing_docs)] - logs(logs), - } - #[automatically_derived] - impl UtilitiesEvents { - /// 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]] = &[ - [ - 11u8, 46u8, 19u8, 255u8, 32u8, 172u8, 123u8, 71u8, 65u8, 152u8, 101u8, - 85u8, 131u8, 237u8, 247u8, 13u8, 237u8, 210u8, 193u8, 220u8, 152u8, 14u8, - 50u8, 156u8, 79u8, 187u8, 47u8, 192u8, 116u8, 139u8, 121u8, 107u8, - ], - [ - 14u8, 181u8, 213u8, 38u8, 36u8, 200u8, 210u8, 138u8, 218u8, 159u8, 197u8, - 90u8, 140u8, 80u8, 46u8, 213u8, 170u8, 63u8, 190u8, 47u8, 182u8, 233u8, - 27u8, 113u8, 181u8, 243u8, 118u8, 136u8, 43u8, 29u8, 47u8, 184u8, - ], - [ - 35u8, 182u8, 42u8, 208u8, 88u8, 77u8, 36u8, 167u8, 95u8, 11u8, 243u8, - 86u8, 3u8, 145u8, 239u8, 86u8, 89u8, 236u8, 109u8, 177u8, 38u8, 156u8, - 86u8, 225u8, 26u8, 162u8, 65u8, 214u8, 55u8, 241u8, 155u8, 32u8, - ], - [ - 40u8, 15u8, 68u8, 70u8, 178u8, 138u8, 19u8, 114u8, 65u8, 125u8, 218u8, - 101u8, 141u8, 48u8, 185u8, 91u8, 41u8, 146u8, 177u8, 42u8, 201u8, 199u8, - 243u8, 120u8, 83u8, 95u8, 41u8, 169u8, 122u8, 207u8, 53u8, 131u8, - ], - [ - 44u8, 171u8, 151u8, 144u8, 81u8, 15u8, 216u8, 189u8, 251u8, 210u8, 17u8, - 82u8, 136u8, 219u8, 51u8, 254u8, 198u8, 102u8, 145u8, 212u8, 118u8, - 239u8, 197u8, 66u8, 124u8, 253u8, 76u8, 9u8, 105u8, 48u8, 23u8, 85u8, - ], - [ - 47u8, 230u8, 50u8, 119u8, 145u8, 116u8, 55u8, 67u8, 120u8, 68u8, 42u8, - 142u8, 151u8, 139u8, 204u8, 251u8, 220u8, 193u8, 214u8, 178u8, 176u8, - 216u8, 31u8, 126u8, 142u8, 183u8, 118u8, 171u8, 34u8, 134u8, 241u8, 104u8, - ], - [ - 65u8, 48u8, 79u8, 172u8, 217u8, 50u8, 61u8, 117u8, 177u8, 27u8, 205u8, - 214u8, 9u8, 203u8, 56u8, 239u8, 255u8, 253u8, 176u8, 87u8, 16u8, 247u8, - 202u8, 240u8, 233u8, 177u8, 108u8, 109u8, 157u8, 112u8, 159u8, 80u8, - ], - [ - 93u8, 166u8, 206u8, 157u8, 81u8, 21u8, 27u8, 161u8, 12u8, 9u8, 165u8, - 89u8, 239u8, 36u8, 213u8, 32u8, 185u8, 218u8, 197u8, 197u8, 184u8, 129u8, - 10u8, 232u8, 67u8, 78u8, 77u8, 13u8, 134u8, 65u8, 26u8, 149u8, - ], - [ - 122u8, 231u8, 76u8, 82u8, 116u8, 20u8, 174u8, 19u8, 95u8, 217u8, 112u8, - 71u8, 177u8, 41u8, 33u8, 165u8, 236u8, 57u8, 17u8, 184u8, 4u8, 25u8, - 120u8, 85u8, 214u8, 126u8, 37u8, 199u8, 183u8, 94u8, 230u8, 243u8, - ], - [ - 156u8, 78u8, 133u8, 65u8, 202u8, 143u8, 13u8, 193u8, 196u8, 19u8, 249u8, - 16u8, 143u8, 102u8, 216u8, 45u8, 60u8, 236u8, 177u8, 189u8, 219u8, 206u8, - 67u8, 122u8, 97u8, 202u8, 163u8, 23u8, 92u8, 76u8, 201u8, 111u8, - ], - [ - 175u8, 183u8, 149u8, 201u8, 198u8, 30u8, 79u8, 231u8, 70u8, 140u8, 56u8, - 111u8, 146u8, 93u8, 122u8, 84u8, 41u8, 236u8, 173u8, 156u8, 4u8, 149u8, - 221u8, 184u8, 211u8, 141u8, 105u8, 6u8, 20u8, 211u8, 47u8, 153u8, - ], - [ - 178u8, 222u8, 47u8, 190u8, 128u8, 26u8, 13u8, 246u8, 192u8, 203u8, 221u8, - 253u8, 68u8, 139u8, 163u8, 196u8, 29u8, 72u8, 160u8, 64u8, 202u8, 53u8, - 197u8, 108u8, 129u8, 150u8, 239u8, 15u8, 202u8, 231u8, 33u8, 168u8, - ], - [ - 210u8, 110u8, 22u8, 202u8, 212u8, 84u8, 135u8, 5u8, 228u8, 201u8, 226u8, - 217u8, 79u8, 152u8, 238u8, 145u8, 194u8, 137u8, 8u8, 94u8, 228u8, 37u8, - 89u8, 79u8, 213u8, 99u8, 95u8, 162u8, 150u8, 76u8, 207u8, 24u8, - ], - [ - 231u8, 149u8, 14u8, 222u8, 3u8, 148u8, 185u8, 242u8, 206u8, 74u8, 90u8, - 27u8, 245u8, 167u8, 225u8, 133u8, 36u8, 17u8, 247u8, 230u8, 102u8, 27u8, - 67u8, 8u8, 201u8, 19u8, 196u8, 191u8, 209u8, 16u8, 39u8, 228u8, - ], - [ - 232u8, 22u8, 153u8, 184u8, 81u8, 19u8, 238u8, 161u8, 199u8, 62u8, 16u8, - 88u8, 139u8, 43u8, 3u8, 94u8, 85u8, 137u8, 51u8, 105u8, 99u8, 33u8, - 115u8, 175u8, 212u8, 63u8, 235u8, 25u8, 47u8, 172u8, 100u8, 227u8, - ], - [ - 235u8, 139u8, 164u8, 60u8, 237u8, 117u8, 55u8, 66u8, 25u8, 70u8, 189u8, - 67u8, 232u8, 40u8, 184u8, 178u8, 184u8, 66u8, 137u8, 39u8, 170u8, 143u8, - 128u8, 28u8, 19u8, 217u8, 52u8, 191u8, 17u8, 172u8, 165u8, 123u8, - ], - ]; - } - #[automatically_derived] - impl alloy_sol_types::SolEventInterface for UtilitiesEvents { - const NAME: &'static str = "UtilitiesEvents"; - const COUNT: usize = 16usize; - fn decode_raw_log( - topics: &[alloy_sol_types::Word], - data: &[u8], - ) -> alloy_sol_types::Result { - match topics.first().copied() { - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_bytes32) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_address) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_bytes32) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_int) - } - Some( - ::SIGNATURE_HASH, - ) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_decimal_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_int) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_named_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log( - topics, - data, - ) - .map(Self::log_string) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::log_uint) - } - Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data) - .map(Self::logs) - } - _ => { - alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::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 UtilitiesEvents { - fn to_log_data(&self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::to_log_data(inner) - } - } - } - fn into_log_data(self) -> alloy_sol_types::private::LogData { - match self { - Self::log(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_address(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_bytes32(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_decimal_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_int(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_named_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_string(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::log_uint(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - Self::logs(inner) => { - alloy_sol_types::private::IntoLogData::into_log_data(inner) - } - } - } - } - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`Utilities`](self) contract instance. - -See the [wrapper's documentation](`UtilitiesInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> UtilitiesInstance { - UtilitiesInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - UtilitiesInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - UtilitiesInstance::::deploy_builder(provider) - } - /**A [`Utilities`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`Utilities`](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 UtilitiesInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for UtilitiesInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("UtilitiesInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > UtilitiesInstance { - /**Creates a new wrapper around an on-chain [`Utilities`](self) contract instance. - -See the [wrapper's documentation](`UtilitiesInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 UtilitiesInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> UtilitiesInstance { - UtilitiesInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > UtilitiesInstance { - /// 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( - &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 [`IS_TEST`] function. - pub fn IS_TEST(&self) -> alloy_contract::SolCallBuilder<&P, IS_TESTCall, N> { - self.call_builder(&IS_TESTCall) - } - ///Creates a new call builder for the [`createUsers`] function. - pub fn createUsers( - &self, - userNum: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, createUsersCall, N> { - self.call_builder(&createUsersCall { userNum }) - } - ///Creates a new call builder for the [`failed`] function. - pub fn failed(&self) -> alloy_contract::SolCallBuilder<&P, failedCall, N> { - self.call_builder(&failedCall) - } - ///Creates a new call builder for the [`getNextUserAddress`] function. - pub fn getNextUserAddress( - &self, - ) -> alloy_contract::SolCallBuilder<&P, getNextUserAddressCall, N> { - self.call_builder(&getNextUserAddressCall) - } - ///Creates a new call builder for the [`mineBlocks`] function. - pub fn mineBlocks( - &self, - numBlocks: alloy::sol_types::private::primitives::aliases::U256, - ) -> alloy_contract::SolCallBuilder<&P, mineBlocksCall, N> { - self.call_builder(&mineBlocksCall { numBlocks }) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > UtilitiesInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - ///Creates a new event filter for the [`log`] event. - pub fn log_filter(&self) -> alloy_contract::Event<&P, log, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_address`] event. - pub fn log_address_filter(&self) -> alloy_contract::Event<&P, log_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes`] event. - pub fn log_bytes_filter(&self) -> alloy_contract::Event<&P, log_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_bytes32`] event. - pub fn log_bytes32_filter(&self) -> alloy_contract::Event<&P, log_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_int`] event. - pub fn log_int_filter(&self) -> alloy_contract::Event<&P, log_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_address`] event. - pub fn log_named_address_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_address, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes`] event. - pub fn log_named_bytes_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_bytes32`] event. - pub fn log_named_bytes32_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_bytes32, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_int`] event. - pub fn log_named_decimal_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_decimal_uint`] event. - pub fn log_named_decimal_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_decimal_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_int`] event. - pub fn log_named_int_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_int, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_string`] event. - pub fn log_named_string_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_named_uint`] event. - pub fn log_named_uint_filter( - &self, - ) -> alloy_contract::Event<&P, log_named_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_string`] event. - pub fn log_string_filter(&self) -> alloy_contract::Event<&P, log_string, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`log_uint`] event. - pub fn log_uint_filter(&self) -> alloy_contract::Event<&P, log_uint, N> { - self.event_filter::() - } - ///Creates a new event filter for the [`logs`] event. - pub fn logs_filter(&self) -> alloy_contract::Event<&P, logs, N> { - self.event_filter::() - } - } -} diff --git a/crates/bindings/src/validate_spv.rs b/crates/bindings/src/validate_spv.rs deleted file mode 100644 index fa396186b..000000000 --- a/crates/bindings/src/validate_spv.rs +++ /dev/null @@ -1,218 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface ValidateSPV {} -``` - -...which was generated by the following JSON ABI: -```json -[] -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod ValidateSPV { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220ee27a3db5def4161da3b0372a7dfce300ba5ffcd5c6cb8bb7aefea14f26619bb64736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"`U`2`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`&WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \xEE'\xA3\xDB]\xEFAa\xDA;\x03r\xA7\xDF\xCE0\x0B\xA5\xFF\xCD\\l\xB8\xBBz\xEF\xEA\x14\xF2f\x19\xBBdsolcC\0\x08\x1C\x003", - ); - /// The runtime bytecode of the contract, as deployed on the network. - /// - /// ```text - ///0x730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220ee27a3db5def4161da3b0372a7dfce300ba5ffcd5c6cb8bb7aefea14f26619bb64736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 \xEE'\xA3\xDB]\xEFAa\xDA;\x03r\xA7\xDF\xCE0\x0B\xA5\xFF\xCD\\l\xB8\xBBz\xEF\xEA\x14\xF2f\x19\xBBdsolcC\0\x08\x1C\x003", - ); - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`ValidateSPV`](self) contract instance. - -See the [wrapper's documentation](`ValidateSPVInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> ValidateSPVInstance { - ValidateSPVInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - ValidateSPVInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - ValidateSPVInstance::::deploy_builder(provider) - } - /**A [`ValidateSPV`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`ValidateSPV`](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 ValidateSPVInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for ValidateSPVInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("ValidateSPVInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ValidateSPVInstance { - /**Creates a new wrapper around an on-chain [`ValidateSPV`](self) contract instance. - -See the [wrapper's documentation](`ValidateSPVInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 ValidateSPVInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> ValidateSPVInstance { - ValidateSPVInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ValidateSPVInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ValidateSPVInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} diff --git a/crates/bindings/src/witness_tx.rs b/crates/bindings/src/witness_tx.rs deleted file mode 100644 index f93a810ef..000000000 --- a/crates/bindings/src/witness_tx.rs +++ /dev/null @@ -1,218 +0,0 @@ -/** - -Generated by the following Solidity interface... -```solidity -interface WitnessTx {} -``` - -...which was generated by the following JSON ABI: -```json -[] -```*/ -#[allow( - non_camel_case_types, - non_snake_case, - clippy::pub_underscore_fields, - clippy::style, - clippy::empty_structs_with_brackets -)] -pub mod WitnessTx { - use super::*; - use alloy::sol_types as alloy_sol_types; - /// The creation / init bytecode of the contract. - /// - /// ```text - ///0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212203dc01a9a718437076a07a4276ef476fe65a24b003d001d99855a279245af3ec464736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"`U`2`\x0B\x82\x82\x829\x80Q_\x1A`s\x14`&WcNH{q`\xE0\x1B_R_`\x04R`$_\xFD[0_R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 =\xC0\x1A\x9Aq\x847\x07j\x07\xA4'n\xF4v\xFEe\xA2K\0=\0\x1D\x99\x85Z'\x92E\xAF>\xC4dsolcC\0\x08\x1C\x003", - ); - /// The runtime bytecode of the contract, as deployed on the network. - /// - /// ```text - ///0x730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212203dc01a9a718437076a07a4276ef476fe65a24b003d001d99855a279245af3ec464736f6c634300081c0033 - /// ``` - #[rustfmt::skip] - #[allow(clippy::all)] - pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static( - b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R__\xFD\xFE\xA2dipfsX\"\x12 =\xC0\x1A\x9Aq\x847\x07j\x07\xA4'n\xF4v\xFEe\xA2K\0=\0\x1D\x99\x85Z'\x92E\xAF>\xC4dsolcC\0\x08\x1C\x003", - ); - use alloy::contract as alloy_contract; - /**Creates a new wrapper around an on-chain [`WitnessTx`](self) contract instance. - -See the [wrapper's documentation](`WitnessTxInstance`) for more details.*/ - #[inline] - pub const fn new< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - >( - address: alloy_sol_types::private::Address, - provider: P, - ) -> WitnessTxInstance { - WitnessTxInstance::::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: alloy_contract::private::Network, - >( - provider: P, - ) -> impl ::core::future::Future< - Output = alloy_contract::Result>, - > { - WitnessTxInstance::::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: alloy_contract::private::Network, - >(provider: P) -> alloy_contract::RawCallBuilder { - WitnessTxInstance::::deploy_builder(provider) - } - /**A [`WitnessTx`](self) instance. - -Contains type-safe methods for interacting with an on-chain instance of the -[`WitnessTx`](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 WitnessTxInstance { - address: alloy_sol_types::private::Address, - provider: P, - _network: ::core::marker::PhantomData, - } - #[automatically_derived] - impl ::core::fmt::Debug for WitnessTxInstance { - #[inline] - fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("WitnessTxInstance").field(&self.address).finish() - } - } - /// Instantiation and getters/setters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > WitnessTxInstance { - /**Creates a new wrapper around an on-chain [`WitnessTx`](self) contract instance. - -See the [wrapper's documentation](`WitnessTxInstance`) for more details.*/ - #[inline] - pub const fn new( - address: alloy_sol_types::private::Address, - provider: P, - ) -> Self { - Self { - address, - 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> { - 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 { - 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 WitnessTxInstance<&P, N> { - /// Clones the provider and returns a new instance with the cloned provider. - #[inline] - pub fn with_cloned_provider(self) -> WitnessTxInstance { - WitnessTxInstance { - address: self.address, - provider: ::core::clone::Clone::clone(&self.provider), - _network: ::core::marker::PhantomData, - } - } - } - /// Function calls. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > WitnessTxInstance { - /// 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( - &self, - call: &C, - ) -> alloy_contract::SolCallBuilder<&P, C, N> { - alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call) - } - } - /// Event filters. - #[automatically_derived] - impl< - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > WitnessTxInstance { - /// 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( - &self, - ) -> alloy_contract::Event<&P, E, N> { - alloy_contract::Event::new_sol(&self.provider, &self.address) - } - } -} From a2019c45d91071e695a814e56c391b0a38348431 Mon Sep 17 00:00:00 2001 From: Sander Bosma Date: Wed, 2 Jul 2025 17:59:30 +0200 Subject: [PATCH 22/24] fix: updated 'make bind' command --- Makefile | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 62b289af1..469d14cb8 100644 --- a/Makefile +++ b/Makefile @@ -17,11 +17,14 @@ bindings: rm -rf $(BINDINGS_OUT_PATH) # Generate new bindings - @forge bind --root $(CONTRACTS_PATH) --crate-name $(BINDINGS_FOLDER) --select FullRelay --alloy --force + @forge bind --root $(CONTRACTS_PATH) --crate-name $(BINDINGS_FOLDER) --select "(FullRelay\$$)|(FullRelayWithVerify\$$)" --alloy --force # Move bindings to the correct location @mv -f $(BINDINGS_OUT_PATH) $(CRATES_FOLDER) +# undo changes to the Cargo.toml file + git checkout $(BINDINGS_CRATES_FOLDER)/Cargo.toml + # Target for building the project build: bindings @$(CARGO) build From 6a78f08f5b3aa4621463bfe81c30ebded32d7923 Mon Sep 17 00:00:00 2001 From: Sander Bosma Date: Wed, 2 Jul 2025 18:07:46 +0200 Subject: [PATCH 23/24] chore: satisfy clippy --- crates/bindings/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/bindings/src/lib.rs b/crates/bindings/src/lib.rs index a9b17e504..72d3ffaff 100644 --- a/crates/bindings/src/lib.rs +++ b/crates/bindings/src/lib.rs @@ -1,4 +1,4 @@ -#![allow(unused_imports, clippy::all, rustdoc::all)] +#![allow(unused_imports, clippy::all, dead_code, rustdoc::all)] //! This module contains the sol! generated bindings for solidity contracts. //! This is autogenerated code. //! Do not manually edit these files. From 42f256fc7aabef417d71d516a2337ed6f2fcb877 Mon Sep 17 00:00:00 2001 From: Sander Bosma Date: Thu, 3 Jul 2025 10:45:57 +0200 Subject: [PATCH 24/24] chore: allow clippy::too_many_arguments --- crates/utils/src/bitcoin_client.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/crates/utils/src/bitcoin_client.rs b/crates/utils/src/bitcoin_client.rs index e5c0a263c..8b8fe5530 100644 --- a/crates/utils/src/bitcoin_client.rs +++ b/crates/utils/src/bitcoin_client.rs @@ -366,6 +366,7 @@ impl BitcoinClient { } } + #[allow(clippy::too_many_arguments)] pub fn send_to_address_with_op_return( &self, address: Option<&Address>, @@ -389,6 +390,7 @@ impl BitcoinClient { Ok(txid) } + #[allow(clippy::too_many_arguments)] pub fn create_and_sign_tx( &self, address: Option<&Address>,